312-96 Sample Questions & Answers

The Java Cryptography Architecture is designed to be extensible through the use of providers. The standard way to add a new provider, like Bouncy Castle, without modifying the JDK installation is to include its JAR in the application's classpath and then call Security.addProvider(new BouncyCastleProvider()) in the application's startup code. This dynamically registers the provider for the current JVM instance, making its algorithms available to the application.

URLs are stored in the browser's history, making the session ID accessible to anyone with access to that history.

Web servers, proxies, and other network appliances often log the full URL of requests, which would include the session ID, potentially exposing it in log files.

Users may unknowingly leak their session by sharing a link from their address bar, allowing others to hijack their session.

The most robust defense against insecure deserialization is to avoid it altogether. Using safe, structured data formats like JSON or XML with a secure parser (e.g., Jackson, GSON) is the recommended practice. These libraries do not execute code during deserialization and are not vulnerable to the gadget chain exploits that affect native Java serialization.

In Spring Boot, the standard and most maintainable way to handle exceptions globally is by creating a class annotated with @ControllerAdvice. Within this class, methods annotated with @ExceptionHandler can catch specific exceptions (or general ones like Exception.class) and define a consistent, safe JSON response structure. This centralizes error handling and prevents sensitive information like stack traces from being leaked to the client.

The jarsigner utility is specifically designed to sign JAR files and verify the signatures of signed JAR files. The build server would use jarsigner with a private key to sign the application JAR. The IoT device would then have the corresponding public certificate and could use jarsigner -verify to confirm both the integrity (the file hasn't been altered) and authenticity (it was signed by the trusted build server) of the JAR before executing it.

False. While PreparedStatement is the primary defense against first-order SQLi by properly separating query logic from user data, it does not protect against all scenarios. For example, if user input is used to dynamically construct parts of the query that cannot be parameterized, such as table names, column names, or ORDER BY clauses, the application can still be vulnerable. It also does not inherently protect against second-order SQL injection, where malicious input is stored in the database and later executed in a different, vulnerable query.

Tampering, in the context of STRIDE, refers to the unauthorized modification of data. In this scenario, one user is modifying data that does not belong to them, which is a clear case of data tampering. The corresponding security property to mitigate this is Integrity, which would be enforced by proper authorization checks.

The most secure and recommended way to initialize SecureRandom is to use the no-argument constructor: new SecureRandom(). This allows the JVM to select the best-configured and most secure Pseudo-Random Number Generator (PRNG) available in the underlying operating system. On Linux, this will typically seed from /dev/urandom or /dev/random, which are cryptographically strong sources of entropy. Manually seeding with a predictable value like System.currentTimeMillis() is insecure, and hardcoding an algorithm like SHA1PRNG is brittle and may not be the strongest option available.

While Spring Security is very popular, Apache Shiro is particularly well-known for its powerful and intuitive permission-based (or resource-based) authorization model. Shiro's WildcardPermission syntax is extremely flexible and naturally supports hierarchical permissions and instance-level access control (e.g., document:edit:12345). This makes it an excellent choice for applications with complex, fine-grained authorization requirements beyond simple role checks.

This option provides a robust and compliant solution. TLS 1.3 is the current standard for secure transit. TDE provides strong encryption at rest at the database level. Critically, session timeouts must be enforced on the server-side, as client-side timeouts can be easily bypassed; configuring this in Spring Boot is the correct approach. The value 900s correctly corresponds to 15 minutes.