Security guy on an escalator

I’ve already written about the JVM security manager, and why it should be used - despite it being rarely the case, if ever. However, just advocating for it won’t change the harsh reality unless some guidelines are provided to do so. This post has the ambition to be the basis of such guidelines.

As a reminder, the JVM can run in two different modes, standard and sandboxed. In the former, all API are available with no restriction; in the later, some API calls deemed sensitive are forbidden. In that case, explicit permissions to allow some of those calls can be configured in a dedicated policy file.

Though running the JVM in sandbox mode is important, it doesn’t stop there .e.g. executing only digitally-signed code is also part of securing the JVM. This post is the first in a 2 parts-serie regarding JVM security.


The process is based on the principle of least privilege. That directly translates into the following process:

  1. Start with a blank policy file
  2. Run the application
  3. Check the thrown security exception
  4. Add the smallest-grained permission possible in the policy file that allows to pass step 2
  5. Return to step 2 until the application can be run normally

Relevant system properties include:

  • activates the Java Security manager
  • points to the desired policy file
  • last but not least, activates debugging information when an absent privilege is required. There are a ton of options.

That sounds easy enough but let’s go detail how it works with an example.

A case study

As a sample application, we will be using the Spring Pet Clinic, a typical albeit small-sized Spring Boot application.

First steps

Once the application has been built, launch it with the security manager:

java -jar target/spring-petclinic-1.4.2.jar

This, of course, fails. The output is the following:

Exception in thread "main" java.lang.IllegalStateException: access denied ("java.lang.RuntimePermission" "getProtectionDomain")
  at org.springframework.boot.loader.ExecutableArchiveLauncher.<init>(
  at org.springframework.boot.loader.JarLauncher.<init>(
  at org.springframework.boot.loader.JarLauncher.main(
Caused by: access denied ("java.lang.RuntimePermission" "getProtectionDomain")
  at java.lang.SecurityManager.checkPermission(
  at java.lang.Class.getProtectionDomain(
  at org.springframework.boot.loader.Launcher.createArchive(
  at org.springframework.boot.loader.ExecutableArchiveLauncher.<init>(
  ... 2 more

Let’s add the permission relevant to the above "access denied" exception to the policy file:

grant codeBase "file:target/spring-petclinic-1.4.2.jar" {
  permission java.lang.RuntimePermission "getProtectionDomain";

Notice the path pointing to the JAR. It prevents other potentially malicious archives to execute critical code. Onto the next blocker.

Exception in thread "main" access denied ("java.util.PropertyPermission" "java.protocol.handler.pkgs" "read")

This can be fixed by adding the below line to the policy file:

grant codeBase "file:target/spring-petclinic-1.4.2.jar" {
  permission java.lang.RuntimePermission "getProtectionDomain";
  permission java.util.PropertyPermission "java.protocol.handler.pkgs", "read";

Next please.

Exception in thread "main" access denied ("java.util.PropertyPermission" "java.protocol.handler.pkgs" "read")

Looks quite similar, but it needs a write permission in addition to the read one. Sure it can be fixed by adding one more line, but there’s a shortcut available. Just specify all necessary attributes of the permission on the same line:

grant codeBase "file:target/spring-petclinic-1.4.2.jar" {
  permission java.lang.RuntimePermission "getProtectionDomain";
  permission java.util.PropertyPermission "java.protocol.handler.pkgs", "read,write";

Rinse and repeat. Without further ado, the (nearly) final policy can be found online: a whooping ~1800 lines of configuration for the Spring Boot Pet Clinic as an executable JAR.

Now that the general approach has been explained, it just needs to be followed until the application functions properly. The next section describe some specific glitches along the way.

Securing Java logging

At some point, nothing gets printed in the console anymore. The command-line just returns, that’s it. Comes the system property - described above, that helps resolve the issue:

java,stacktrace -jar target/spring-petclinic-1.4.2.jar

That yields the following stack:

java.lang.Exception: Stack trace
  at java.lang.Thread.dumpStack(
  at java.lang.SecurityManager.checkPermission(
  at java.util.logging.LogManager.checkPermission(
  at java.util.logging.Logger.checkPermission(
  at java.util.logging.Logger.setLevel(
  at java.util.logging.LogManager.resetLogger(
  at java.util.logging.LogManager.reset(
  at java.util.logging.LogManager$

It’s time for some real software engineering (also known as Google Search). The LogManager’s Javadoc tells about the LoggingPermission that needs to be added to the existing list of permissions:

grant codeBase "file:target/spring-petclinic-1.4.2.jar" {
  permission java.lang.RuntimePermission "getProtectionDomain";
  permission java.util.PropertyPermission "PID", "read,write";
  permission java.util.logging.LoggingPermission "control";

That makes it possible to go further.

Securing the reading of system properties and environment variables

It’s even possible to watch Spring Boot log…​ until one realizes it’s made entirely of error messages about not being able to read a bunchload of system properties and environment variables. Here’s an excerpt:

2017-01-22 00:30:17.118  INFO 46549 --- [           main] o.s.w.c.s.StandardServletEnvironment     :
  Caught AccessControlException when accessing system environment variable [logging.register_shutdown_hook];
  its value will be returned [null].
  Reason: access denied ("java.lang.RuntimePermission" "getenv.logging.register_shutdown_hook")
2017-01-22 00:30:17.118  INFO 46549 --- [           main] o.s.w.c.s.StandardServletEnvironment     :
  Caught AccessControlException when accessing system property [logging_register-shutdown-hook];
  its value will be returned [null].
  Reason: access denied ("java.util.PropertyPermission" "logging_register-shutdown-hook" "read")

I will spare you dear readers a lot of trouble: there’s no sense in configuring every property one by one as JCache requires read and write permissions on all properties. So just remove every fine-grained PropertyPermission so far and replace it with a catch-all coarse-grained one:

permission java.util.PropertyPermission "*", "read,write";

Seems like security was not one of JCache developers first priority. The following snippet is the code excerpt for javax.cache.Caching.CachingProviderRegistry.getCachingProviders():

if (System.getProperties().containsKey(JAVAX_CACHE_CACHING_PROVIDER)) {
    String className = System.getProperty(JAVAX_CACHE_CACHING_PROVIDER);

Wow, it reads all properties! Plus the next line makes it a little redundant, no?

As for environment variables, the Spring team seem to try to avoid developers configuration issues related to case and check every possible case combination, so there is a lot of different options.

Variables and subdirectories

At one point, Spring’s embedded Tomcat attempts - and fails, to create a subfolder into the folder.

java.lang.SecurityException: Unable to create temporary file
  at ~[na:1.8.0_92]
  at ~[na:1.8.0_92]
  at org.springframework.boot.context.embedded.AbstractEmbeddedServletContainerFactory.createTempDir(...)
  at org.springframework.boot.context.embedded.tomcat.TomcatEmbeddedServletContainerFactory.getEmbeddedServletContainer(...)
  at org.springframework.boot.context.embedded.EmbeddedWebApplicationContext.createEmbeddedServletContainer(...)
  at org.springframework.boot.context.embedded.EmbeddedWebApplicationContext.onRefresh(...)
  ... 16 common frames omitted

One could get away with that by "hard-configuring" the path, but that would just be a major portability issue. Permissions are able to use System properties.

The second issue is the subfolder: there’s no way of knowing the folder name, hence it’s not possible to configure it beforehand. However, file permissions accept any direct children or any descendant in the hierarachy; the former is set with jokers, and the second with dashes. The final configuration looks like this:

permission "${}/-", "read,write,delete";

CGLIB issues

CGLIB is used heavily in the Spring framework to extend classes at compile-time. By default, the name of a generated class:

[…​] is composed of a prefix based on the name of the superclass, a fixed string incorporating the CGLIB class responsible for generation, and a hashcode derived from the parameters used to create the object.

Consequently, one if faced with the following exception: access denied (""
  at ~[na:1.8.0_92]
  at [na:1.8.0_92]
  at java.lang.SecurityManager.checkPermission( ~[na:1.8.0_92]
  at java.lang.SecurityManager.checkRead( ~[na:1.8.0_92]
  at ~[na:1.8.0_92]
  at org.apache.catalina.webresources.DirResourceSet.getResource(...)
  at org.apache.catalina.webresources.StandardRoot.getResourceInternal(...)
  at org.apache.catalina.webresources.Cache.getResource( ~[tomcat-embed-core-8.5.6.jar!/:8.5.6]
  at org.apache.catalina.webresources.StandardRoot.getResource(...)
  at org.apache.catalina.webresources.StandardRoot.getClassLoaderResource(...)
  at org.apache.catalina.loader.WebappClassLoaderBase.findClassInternal(...)
  at org.apache.catalina.loader.WebappClassLoaderBase$
  at org.apache.catalina.loader.WebappClassLoaderBase$
  at Method) [na:1.8.0_92]
  at org.apache.catalina.loader.WebappClassLoaderBase.findClass()
  at org.springframework.boot.context.embedded.tomcat.TomcatEmbeddedWebappClassLoader.findClassIgnoringNotFound()
  at org.springframework.boot.context.embedded.tomcat.TomcatEmbeddedWebappClassLoader.loadClass()
  at org.apache.catalina.loader.WebappClassLoaderBase.loadClass(...)
  at java.lang.Class.forName0(Native Method) [na:1.8.0_92]
  at java.lang.Class.forName( [na:1.8.0_92]

It looks quite an easy file permission fix, but it isn’t: for whatever reason, the hashcode used by CGLIB to extend MultipartAutoConfiguration changes at every compilation. Hence, a more lenient generic permission is required:

permission "src/main/webapp/WEB-INF/classes/org/springframework/boot/autoconfigure/web/*", "read";

Launching is not the end

Unfortunately, once the application has been successfully launched doesn’t mean it stops there. Browsing the home page yields a new bunch of security exceptions.

For example, Tomcat needs to bind to port 8080, but this is a potential insecure action: access denied ("" "localhost:8080" "listen,resolve")

The permission to fix it is pretty straightforward:

permission "localhost:8080", "listen,resolve";

However, actually browsing the app brings a new exception: access denied ("" "[0:0:0:0:0:0:0:1]:56733" "accept,resolve")

That wouldn’t be bad if the port number didn’t change with every launch. A few attempts reveal that it seems to start from around 55400. Good thing that the socket permission allows for a port range:

permission "[0:0:0:0:0:0:0:1]:55400-", "accept,resolve";

Lessons learned

Though it was very fulfilling to have created the policy file, the true value lies in the lessons learned.

  • The crafting of a custom policy file for a specific application is quite trivial, but very time-consuming. I didn’t finish completely and spent around one day for a small-sized application. Time might be a valid reason why policy files are never in use.
  • For large applications, I believe it’s not only possible but desirable to automate the crafting process: run the app, read the exception, create the associated permission, and update the policy file accordingly.
  • Patterns are recognizable in the policy file: sets of permissions are dedicated to a specific library, such as Spring Boot’s actuator. If each framework/library would provide the minimum associated policy file that allows it to work correctly, crafting a policy file for an app would just mean aggregating all files for every library.
  • Randomness (such as random port number) and bad coding practices (such as JCache’s) require more coarse-grained permissions. On one hand, it speeds up the crafting process; on the other hand, it increases the potential attack surface.

In all cases, running the JVM in sandbox mode is not an option in security-aware environments.

To go further: