CCNA Security Engineering Questions

ESP encrypts the payload and provides integrity plus data-origin authentication, meeting the confidentiality requirement that AH cannot. Tunnel mode encapsulates the whole packet between the site gateways, protecting the sensitive financial records across the untrusted link.

Code signing with a trusted certificate lets each IoT sensor verify the firmware's signature against the vendor's public key before installation, confirming both integrity and origin. Unsigned or tampered images are rejected, satisfying the OTA authenticity requirement.

Ephemeral Diffie-Hellman generates a fresh key pair per session and discards it afterward, so the session key is never derivable from the server's long-term private key. Even if that long-term key is later compromised, previously recorded sessions remain protected. Static RSA key transport encrypts the premaster secret with the long-term key, so its compromise retroactively exposes past sessions, which is exactly the property ephemeral DH adds.

Generating the key inside the HSM with the non-extractable attribute ensures the private key material never leaves the cryptographic boundary in plaintext. M of N quorum authentication enforces dual control by requiring multiple smartcards or credentials to authorize sensitive operations, directly meeting both requirements.

The UEFI signature database (db) contains certificates and hashes of trusted bootloaders and drivers. During boot, the UEFI firmware verifies the signature of the bootloader against the entries in the db. If the bootloader's signature matches a trusted certificate in the db, it is allowed to execute. This is the component directly responsible for verification.

FIPS 140-2 Level 3 requires tamper-evident mechanisms such as epoxy encapsulation or tamper-detection circuitry that zeroizes keys upon intrusion, and it mandates identity-based authentication for all operators accessing the module. This directly meets the requirement that keys never leave the hardware and the module resists physical tampering. Level 3 is the correct validation level for this scenario because it adds physical security and identity-based authentication beyond Level 2's role-based authentication.

Learning mode establishes a baseline of legitimate traffic, allowing the engineer to tune rules and reduce false positives. Targeted rules for SQL injection and XSS address the specific threats, and virtual patching protects against known vulnerabilities until code fixes are deployed. This approach balances protection with operational stability.

Recording administrative sessions and protecting the log stream with TLS plus a hash chain makes the recordings tamper-evident: any modification breaks the chain and is detectable. Remote storage prevents a local attacker from altering or deleting recordings on the bastion host. This directly satisfies the tamper-evident session recording requirement while complementing hardware-backed authentication.

FIDO2/WebAuthn credentials are bound to the relying party's origin, and the authenticator signs a challenge with a private key that never leaves the device. A phishing site on a different origin cannot obtain a valid assertion, eliminating credential replay regardless of password reuse.

Shipping logs off-host in real time means a compromised server no longer holds the only copy, and append-only storage with tightly restricted administration prevents alteration or deletion. This directly satisfies the requirement that a single compromised server cannot tamper with the collected log data.

EAP-TLS requires both the server and client to present certificates. By configuring the RADIUS server to trust only the corporate CA and to require client certificates, the engineer ensures that only devices with valid certificates issued by that CA can authenticate. This meets the requirement exactly and is considered the most secure EAP method.

Tunnel mode encapsulates the entire original IP packet, including its header, inside a new IP packet, whereas transport mode protects only the payload. ESP supplies the encryption, so tunnel mode with ESP encrypts the whole packet as the stem requires.

Mutual TLS with short-lived certificates provides strong authentication and encryption for inter-service communication. Short-lived certificates reduce the risk of key compromise and enable automatic rotation. This ensures that only authenticated services can communicate, and all traffic is encrypted, meeting the requirements for secure service-to-service communication.

Signed firmware images let the device verify authenticity and integrity before flashing, using the vendor’s public key to validate the private-key signature. This directly satisfies the stem’s requirement for a trustworthy update process, preventing tampered or malicious firmware from being installed on the IoT device.

A high-assurance guard combines a formally verified security kernel with content filtering and a controlled release process, which is exactly what is needed to enforce a non-bypassable information-flow policy while permitting approved structured data to cross. The formal verification provides the assurance evidence that the policy cannot be bypassed, and the filtering performs the necessary sanitization.

Tunnel mode encapsulates the complete original IP packet inside a new IP packet, encrypting payload and original header together. Transport mode encrypts only the payload and leaves the original header intact, so tunnel mode is required to meet the stated requirement of encrypting the entire packet.

Event ID 4625 is generated whenever a logon attempt fails, such as due to a bad password or unknown username. A high volume of 4625 events from a single source or against a single account within a short time frame is a classic indicator of a brute-force or password-spraying attack. Monitoring and alerting on this event is essential for early detection of credential attacks against local accounts.

AH provides data integrity and origin authentication through its ICV, but performs no encryption, matching the stated indifference to confidentiality. Tunnel mode encapsulates the entire original IP packet, protecting traffic between the two site gateways rather than just host-to-host flows.

RekeyLimit specifies the maximum amount of data and/or time before the session key is renegotiated. Setting it to 1G 1h forces a new key exchange after 1 gigabyte of data or one hour, whichever comes first, thereby rotating session keys and limiting exposure if a key is compromised. This directly satisfies the requirement.

EAP-TLS uses mutual certificate-based authentication, where both the supplicant and the authentication server present certificates. This ensures the server validates the supplicant's identity and vice versa, meeting the requirement. It is widely supported in WPA3-Enterprise and provides strong security without passwords, making it ideal for environments requiring robust mutual authentication.

Separating the wrapping key into a distinct HSM under dual control enforces separation of duties and prevents a single compromised HSM from exposing backed-up keys. Logging wrapping operations provides the required auditability. This design ensures that even if the primary HSM is compromised, the attacker cannot unwrap exported blobs without also compromising the second HSM.

Real-time forwarding removes logs from the source host before an attacker can tamper with them, and append-only storage with hash chaining makes any later modification detectable because each entry's hash depends on the previous one. An attacker with server administrative rights cannot rewrite records already transmitted to the hardened collector. This directly provides tamper evidence and verifiability.

WPA2-Personal with a strong PSK accommodates legacy devices that cannot use 802.1X. A WIPS monitors the airwaves for rogue access points and can detect and mitigate unauthorized devices. This combination meets the requirements without requiring device upgrades, balancing compatibility and security.

SSH provides strong encryption, integrity, and authentication for remote administration. It protects the session against eavesdropping and tampering. It is the standard protocol for secure command-line management. Using SSH meets the requirement for confidentiality and integrity of the management session.

A site-to-site VPN with a customer gateway on-premises and a virtual private gateway in the cloud encrypts traffic via IPsec, and advertising only the database subnet CIDR in the static route confines reachable destinations to that network. This meets both the encryption requirement and the least-privilege routing constraint without exposing other on-premises ranges.

Remote attestation lets the TPM sign a quote over selected PCR values, allowing a remote verifier to confirm the boot chain matched expected measurements. This satisfies the integrity-verification requirement by detecting tampering with firmware or boot components before trust is granted.

MAB authenticates devices based on their MAC address, which is easily spoofable. An attacker with physical port access can configure a device with a permitted MAC address and gain network access without valid 802.1X credentials. This directly undermines the requirement that unauthorized devices cannot communicate, making MAB a significant weakness in this scenario.

A hardware OTP token is a possession factor because authentication requires something the user physically holds, satisfying the MFA requirement for a possession-based credential. The device generates time-synchronised one-time codes, so access depends on possessing the hardware itself rather than knowledge or biometrics.

TLS 1.3 mandates forward secrecy by design, using ephemeral Diffie-Hellman key exchange for all cipher suites. Each session generates a unique ephemeral key pair that is discarded after the handshake, so compromise of the server's long-term private key cannot decrypt recorded past sessions. This directly satisfies the requirement and aligns with PCI DSS guidance for strong cryptography.

WPA3-Enterprise uses 802.1X with EAP to authenticate each user or device against a RADIUS server, eliminating the shared-secret weakness of pre-shared keys. It also mandates stronger cryptographic protections, including protected management frames and, in WPA3-Enterprise 192-bit mode, GCMP-256 and SHA-384. This directly satisfies the requirement for strong encryption without a pre-shared key.

Just-in-time access grants elevated privileges only when requested and approved for a defined window, then automatically revokes them. This matches the stem's requirement for temporary elevated access for a specific task, rather than standing permanent admin rights.

Kubernetes Network Policies are the native mechanism to control pod-to-pod traffic at Layer 3 and Layer 4. By applying a default-deny policy for both ingress and egress in a namespace, all traffic is blocked unless explicitly allowed by a subsequent policy. This enforces least privilege and prevents lateral movement between microservices. It works with a CNI plugin that supports network policies, such as Calico or Cilium, and is the standard way to achieve microsegmentation in Kubernetes.

PCRs hold cumulative hashes of boot components, and their values can be signed by the TPM's attestation key. A remote verifier compares these quotes against known-good values, confirming the system booted untampered — the core mechanism enabling remote attestation of boot state.

Non-extractable keys that never leave the HSM boundary ensure the private key cannot be copied or exfiltrated, satisfying the key-protection requirement. Because signing happens inside the module, the plaintext key is never exposed to the host OS or application memory, which is exactly the property needed for a code-signing root of trust.

EAP-TTLS and PEAP create an encrypted TLS tunnel using the server certificate, and the actual user identity and credentials are exchanged inside that tunnel. This protects the supplicant identity from passive eavesdroppers and prevents credential theft. A method that sends identity in the clear before the tunnel, such as EAP-MD5, does not meet the requirement.

FIDO2/WebAuthn credentials are cryptographically bound to the relying party's origin, so a credential registered for the genuine sign-in endpoint cannot be replayed against a look-alike phishing domain. This origin binding satisfies the stem's passwordless requirement while eliminating credential theft via reverse-proxy phishing kits such as Evilginx, which defeat OTP-based MFA.

Just-in-time access provisioning grants privileged accounts only for an approved, time-bound window, and credential rotation replaces the password after each session. Together these satisfy both stated requirements: temporary access on request and automatic rotation following use.

OCSP stapling lets the server fetch a signed, timestamped revocation response and present it during the TLS handshake, so clients avoid downloading the full CRL or contacting the OCSP responder directly. This satisfies the stem's constraint of efficient revocation checking without full CRL downloads, while reducing latency and privacy leakage.

TDE encrypts the database files at rest, and storing the encryption keys in an HSM ensures that the keys are protected and never exposed in software. Without the HSM, the stolen files cannot be decrypted, meeting the requirement. This approach provides strong protection for data at rest with hardware-based key management.

A FIPS 140-3 Level 3 validated HSM provides tamper-responsive physical security, detects and responds to tampering by zeroizing keys, and performs cryptographic operations internally. It meets the requirements for protecting long-term private keys against extraction and ensures operations occur in a secure environment, making it the most appropriate solution.

With SSLVerifyClient require, the server must validate the client's chain against a configured trust anchor; without a correct SSLCACertificateFile (or SSLCACertificatePath) the handshake aborts because the presented certificate cannot be chained to a trusted root. Pointing this directive at the internal CA resolves the failure, which makes it the most likely cause here.

Constant-time implementations execute identical instruction sequences and memory access patterns regardless of key or plaintext values, eliminating the timing variance the analyst observed. This removes the correlation between execution duration and secret data that enables timing attacks.

JIT provisioning grants privileged rights only for the approved duration, then revokes them automatically. This directly shrinks the attack surface created by standing accounts, whose credentials remain valid indefinitely. The reduced exposure window satisfies the scenario's core requirement: limiting how long compromised or misused privileged credentials stay exploitable.

A protocol-aware inspection device parses Modbus/TCP function codes and can permit read or polling functions while dropping write functions from engineering workstations. This directly constrains what a compromised workstation can do to the controllers without blocking legitimate polling. Because it operates at the application layer of the industrial protocol, it addresses the specific unauthorized write risk.

This is the standard hybrid encryption pattern: AES-GCM provides confidentiality and integrity for the message, RSA-OAEP key wrapping delivers the unique symmetric key only to the recipient, and a sender signature provides authentication and non-repudiation. Because the symmetric key is random per message, compromise of one key does not affect other messages, and the server never sees the plaintext key.

OCSP returns a signed, per-certificate revocation status from a responder, so clients query one certificate rather than downloading and parsing an entire CRL. This satisfies the requirement for fast revocation checking without transferring a large list.

A keyed hash is deterministic for a given input and key, so identical values produce identical digests and the database can index and match them for equality searches. Because the key lives outside the database, administrators and backup thieves see only digests they cannot reverse or verify without the key, meeting both the confidentiality and lookup requirements.

Disabling password authentication removes the credential-guessing vector entirely, forcing key-based access that resists brute force. Restricting key exchange to curve25519-sha256 enforces ephemeral elliptic-curve Diffie-Hellman, delivering forward secrecy so compromised long-term keys cannot decrypt past sessions. Together these satisfy both the brute-force and forward-secrecy constraints in the stem.

mTLS ensures that both the client and server authenticate each other using certificates. Short-lived certificates limit the window of compromise and force frequent re-authentication, aligning with zero trust principles. This mechanism provides strong identity verification for each API request, and when combined with a policy engine, enables continuous authorization decisions based on certificate attributes.

Public-key authentication replaces reusable passwords with a private key the client holds, so there is no shared secret to brute-force or steal through phishing. Disabling password authentication removes that credential path entirely, directly shrinking the attack surface.

Envelope encryption keeps bulk data encrypted under a data key, while the HSM holds the master key that wraps it. The backup application can copy ciphertext freely, but unwrapping the data key happens only inside the HSM under its usage policy, so the plaintext key never leaves the module. This satisfies both the at-rest protection and HSM-enforced control requirements.

dm-verity is a device-mapper target that stores a hash tree and verifies each block as it is read, with the root hash protected by a signature. If an attacker alters data offline, the recomputed hash will not match the tree and reads fail. This provides detection of at-rest tampering even when the disk is modified outside the running system, exactly matching the requirement.

Ed25519 signatures verify firmware authenticity with minimal computation, satisfying the constrained processor and memory requirement. Its compact 64-byte signatures and 32-byte keys reduce storage and transmission overhead, while verification is far faster than RSA at equivalent security. This makes it ideal for OTA updates on resource-limited IoT devices.

Encrypting at the application layer with keys resident in an HSM means the ciphertext stored on the shared array is useless without the HSM, and role separation prevents the storage administrator from accessing key material. This directly satisfies both the confidentiality requirement for copied volumes and the key-access restriction.

Full-disk encryption protects data only when the system is powered off or the volume is locked. Once the OS is running and the volume is decrypted, any process or remote attacker with sufficient privileges can read the data. The TPM unseals the key during boot, so the disk remains transparently accessible. This limitation means additional controls like file-level encryption or access controls are needed for runtime protection.

Pinning the public key rather than the full certificate lets the app continue trusting the server after certificate renewal, provided the key pair is reused. This maintains man-in-the-middle protection while avoiding outages from routine certificate rotation.

0-RTT allows a returning client to send application data in the first flight using a previously established pre-shared key, eliminating a round trip. This satisfies the reduced-latency requirement unique to TLS 1.3, though it carries replay risk that deployments must mitigate.

Pinning the server's public key, rather than the whole certificate, survives certificate renewal because the key pair persists across reissues. This satisfies the mobile app's requirement to block man-in-the-middle attacks without breaking connectivity each time the certificate rotates.

The TLS 1.3 key schedule uses HKDF to derive secrets from the shared ECDHE value and the handshake transcript hash, producing traffic keys for each direction. Those derived keys are what the AEAD ciphers use, so the key schedule underpins confidentiality and integrity by ensuring unique, context-bound keys per session and epoch.

ChaCha20 is a stream cipher, generating a keystream from a 256-bit key and nonce that is XORed with plaintext. This distinguishes it from block ciphers such as AES, and explains its efficiency in software without dedicated hardware acceleration.

TLS_AES_256_GCM_SHA384 uses ephemeral Diffie-Hellman key exchange, which is mandatory in TLS 1.3, delivering the required forward secrecy. AES-256-GCM provides authenticated encryption with hardware-accelerated performance, while SHA-384 strengthens the handshake. It satisfies both the forward secrecy and high-performance constraints.

Each boot stage must be digitally signed by a trusted authority, and the signature must be verified before execution. This ensures that only authorized code runs. Without verification, an attacker could replace a boot stage with malicious code. The verification uses the public key from the root of trust or a chain of trust.

Allowing only ports 80 and 443 from any source restricts inbound access to the web services, which is exactly what the public web application requires. Dropping all other inbound traffic reduces the attack surface by preventing access to other services. This is a fundamental host-based firewall hardening step that directly addresses the requirement.

Key-based authentication removes password brute-forcing and credential-replay vectors entirely, since possession of the private key is required. This directly reduces the attack surface on the jump host, satisfying the stem's requirement to restrict authentication to the most secure method.

Restricting HMAC to SHA-2 or stronger removes MD5 and SHA-1 message authentication codes, which are collision-prone and deprecated. This directly satisfies the policy's requirement to disable legacy algorithms, since SSH MAC negotiation would otherwise still permit these weak integrity checks.

ECDHE generates an ephemeral key pair per session, then discards the private key, so compromising the long-term certificate key cannot decrypt past sessions — satisfying TLS 1.3's PFS requirement. TLS 1.3 mandates ephemeral Diffie-Hellman, and ECDHE is its recommended elliptic-curve instantiation, unlike static RSA key transport.

Order of volatility dictates that the most perishable evidence, such as RAM contents and active network connections, must be collected before anything else because it is lost on shutdown or even over time. Capturing memory and live connections first preserves artifacts that no disk image can recover.

FIDO2/WebAuthn binds credentials to the origin's domain via public-key cryptography, so a phishing site on a different domain cannot trigger or replay the authentication. This origin-binding satisfies the phishing-resistance requirement, unlike OTP or push methods vulnerable to real-time relay.

RADIUS traditionally uses UDP ports 1812 (authentication) and 1813 (accounting). These are the official IANA-assigned ports. While some legacy implementations use 1645 and 1646, the standard ports are 1812 and 1813. This is a correct statement about RADIUS.

A signed, cacheable status list lets resource servers reject tokens that the authorization server (or a recovery process) marks as invalid without a per-request call to the issuer. Because the list is signed and versioned, resource servers can refresh it on a schedule and honor the most recent revocation state, bounding the acceptance window after a compromise while keeping request-path latency low.

ForceCommand internal-sftp makes the server run the built-in SFTP subsystem for every matched session regardless of what the client requests, so no shell is ever spawned, and ChrootDirectory confines each partner to their own directory tree with the path token expanded per account. This pairing delivers file transfer without interactive shell access.

Intel SGX creates hardware-isolated enclaves within the CPU, encrypting code and data in memory so even the operating system or hypervisor cannot read them. This directly satisfies the stem's requirement for hardware-enforced isolation of sensitive computations, providing stronger protection than virtualisation or process-level sandboxing alone.

Disabling PasswordAuthentication enforces key-only access, satisfying the key-based constraint, while explicitly restricting Ciphers and MACs to strong algorithms removes weak cryptographic suites. Together these directives harden the SSH daemon against both password brute force and downgrade attacks on the jump host.

TPM 2.0 provides the hardware root of trust: it stores boot measurements in Platform Configuration Registers and holds the attestation key used for remote attestation. PCRs reside in shielded TPM memory, so software cannot rewrite them, satisfying the tamper-resistant integrity measurement constraint.

Curve25519-sha256 and its libssh.org alias implement X25519, an elliptic-curve Diffie-Hellman exchange that does not use finite-field modular exponentiation and provides strong forward secrecy. Restricting KexAlgorithms to these two entries removes all classic DH group1/group14-sha1 and ECDH NIST-curve options, satisfying the requirement to avoid finite-field DH based key exchange.