VULNARCHIVE

Apache Struts2 Core and Plugins <=7.4.0 Multiple Null Pointer Exceptions

Daniel Owens via Fulldisclosure ·

The Apache Struts2 Core, Apache Struts2 Convention Plugin, Apache Struts2 REST plugin, and the Apache Struts2 
JavaTemplates plugin, Apache Struts2 Tiles plugin, etc., all versions <=7.4.0/<=6.12.0/etc., dereference or iterate 
over data that can be non-null -- such as an unmapped configuration lookup, an absent collection element, a failed 
backing-store lookup, an unselected optional upload field, or an unresolved expression-language property, a security 
pattern-matching call invoked with no candidate expression to test, or a missing bundle entry's substituted default 
message -- without first checking whether that value is `null`.

Impact
Any caller -- an attacker or an entirely ordinary user -- who executes a code path in which the underlying value is 
absent or `null` (e.g., an incomplete configuration hierarchy, a missing or empty form field, a non-existent lookup 
key, an unselected optional upload, or application data that simply does not expose the expected property) will cause 
an uncaught `NullPointerException` to bubble up the stack, resulting in a `500 Internal Server Error`.  This may result 
in information disclosure -- either directly or otherwise - and, like all `500` responses, signals to malicious 
entities that the information system contains significant bugs, errors, and unintended side effects brought about by 
unexpected input and edge cases.

While these may seem to merely be "reliability bugs", they undermine the availability of systems that rely upon the 
underlying code, especially if the victim is on behind a load balancer or other front-end system that sees a `500 
Internal Server Error` as a sign of an unhealthy environment and tears it down.  Moreover, it is not inconceivable that 
a configuration file or variable is non-null in development, staging, or elsewhere but not in production, resulting in 
unexpected exceptions and other issues that either were not identified during testing or could not have been identified 
in testing.  It should also be noted that these kinds of issues are examples of poor coding standards, testing, and 
weak peer-review processes.

Examples
As with many of the previously released advisories, there are many instances of this, so we will limit it to a subset 
of instances from which the others may be derived -- again, for the sake of brevity and because it simply isn't our job 
to enumerate all instances of a single vulnerable (like with the Struts2 insecure JSON deserialisation pathways where 
we made clear the issue, mechanisms, and proof of concept while also citing sample responsible code and providing 
detailed analysis thereof).  Please excuse us for our terseness on this one -- we have written up many of these, as of 
late, and the rather glaring theme and sheer number of issues makes such write-ups time consuming (old code or not, all 
of these are things that have been well-documented, frowned upon coding paradigms and constructs for literal decades, 
long before any of the code in question was written) -- and this is all without getting into the more "juicy" findings.

RangeValidatorSupport -- Null Elements
`RangeValidatorSupport.validate(Object)`, in `struts2-core`, only `null`-checks the top-level array- or 
`Collection`-typed field before iterating over the elements and passing each one to `validateValue(Object, Comparable, 
T, T)`, which can call to `value.compareTo(min)` and `value.compareTo(max)` -- so a single `null` element inside an 
otherwise non-`null` collection will cause a `NullPointerException`.

```java
public void validate(Object object) throws ValidationException {
    Object obj = getFieldValue(getFieldName(), object);

    // if there is no value - don't do comparison
    // if a value is required, a required validator should be added to the field
    if (obj == null) {
        return;
    }

    T min = getMin();
    T max = getMax();

    if (obj.getClass().isArray()) {
        Object[] values = (Object[]) obj;
        for (Object objValue : values) {
            validateValue(object, (Comparable<T>) objValue, min, max);
        }
    } else if (Collection.class.isAssignableFrom(obj.getClass())) {
        Collection<?> values = (Collection<?>) obj;
        for (Object objValue : values) {
            validateValue(object, (Comparable<T>) objValue, min, max);
        }
    } else {
        validateValue(object, (Comparable<T>) obj, min, max);
    }
}
```
Code snippet from `struts2-core`'s 
core/src/main/java/org/apache/struts2/validator/validators/RangeValidatorSupport.java, lines 46-71

```java
protected void validateValue(Object object, Comparable<T> value, T min, T max) {
    setCurrentValue(value);

    // only check for a minimum value if the min parameter is set
    if ((min != null) && (value.compareTo(min) < 0)) {
        addFieldError(getFieldName(), object);
    }

    // only check for a maximum value if the max parameter is set
    if ((max != null) && (value.compareTo(max) > 0)) {
        addFieldError(getFieldName(), object);
    }

    setCurrentValue(null);
}
```
Snippet from `struts2-core`'s core/src/main/java/org/apache/struts2/validator/validators/RangeValidatorSupport.java, 
lines 73-87, showing the unconditional `value.compareTo` dereference

DoubleRangeValidator -- Null Elements
`DoubleRangeFieldValidator`, in `struts2-core`, does not extend `RangeValidatorSupport<T>` the way that 
`IntRangeFieldValidator`, `LongRangeFieldValidator`, `ShortRangeFieldValidator`, and `LocalDateRangeFieldValidator` all 
do -- it implements its own `validate(Object)`, `validateCollection(Double, Double, Double, Double, Collection)`, and 
`validateValue(Object, Double, Double, Double, Double)` methods -- and contains the identical problematic code but 
under the `validate` to `validateCollection` pathway, which, again, only performs a nullness check on the top-level 
object, but, this time, the exception occurs when `validateValue` unconditionally calls `Object.toString()` inside of a 
try-catch block that only handles `NumberFormatException`.

```java
    public void validate(Object object) throws ValidationException {
        String fieldName = getFieldName();
        Object obj = this.getFieldValue(fieldName, object);
        if (obj == null) {
            return;
        }

        Double maxInclusiveToUse = getMaxInclusive();
        Double minInclusiveToUse = getMinInclusive();
        Double maxExclusiveToUse = getMaxExclusive();
        Double minExclusiveToUse = getMinExclusive();

        if (obj.getClass().isArray()) {
            Object[] values = (Object[]) obj;
            validateCollection(maxInclusiveToUse, minInclusiveToUse, maxExclusiveToUse, minExclusiveToUse, 
Arrays.asList(values));
        } else if (Collection.class.isAssignableFrom(obj.getClass())) {
            Collection values = (Collection) obj;
            validateCollection(maxInclusiveToUse, minInclusiveToUse, maxExclusiveToUse, minExclusiveToUse, values);
        } else {
            validateValue(obj, maxInclusiveToUse, minInclusiveToUse, maxExclusiveToUse, minExclusiveToUse);
        }
    }

    protected void validateCollection(Double maxInclusiveToUse, Double minInclusiveToUse, Double maxExclusiveToUse, 
Double minExclusiveToUse, Collection values) {
        for (Object objValue : values) {
            validateValue(objValue, maxInclusiveToUse, minInclusiveToUse, maxExclusiveToUse, minExclusiveToUse);
        }
    }
```
Code snippet from `struts2-core`'s 
core/src/main/java/org/apache/struts2/validator/validators/DoubleRangeFieldValidator.java, lines 109-136, showing the 
top-level-only null check at line 112 and `validateCollection()`'s per-element iteration with no null check

```java
    protected void validateValue(Object obj, Double maxInclusiveToUse, Double minInclusiveToUse, Double 
maxExclusiveToUse, Double minExclusiveToUse) {
        try {
            setCurrentValue(obj);
            Double value = Double.valueOf(obj.toString());
            if ((maxInclusiveToUse != null && value.compareTo(maxInclusiveToUse) > 0) ||
                    (minInclusiveToUse != null && value.compareTo(minInclusiveToUse) < 0) ||
                    (maxExclusiveToUse != null && value.compareTo(maxExclusiveToUse) >= 0) ||
                    (minExclusiveToUse != null && value.compareTo(minExclusiveToUse) <= 0)) {
                addFieldError(getFieldName(), value);
            }
        } catch (NumberFormatException e) {
            LOG.debug("Cannot validate value {} - not a Double", obj, e);
        } finally {
            setCurrentValue(null);
        }
    }
```
Snippet from `struts2-core`'s 
core/src/main/java/org/apache/struts2/validator/validators/DoubleRangeFieldValidator.java, lines 138-153, showing the 
unconditional `obj.toString()` call and the `catch` clause that handles only `NumberFormatException`

FileUploadAction/MultipleFileUploadUsingArrayAction -- Nullable Optional Upload
`FileUploadAction.getUploadedFile()` and `MultipleFileUploadUsingArrayAction.upload()`, both in `struts2-showcase`, 
dereference or iterate over their respective `uploadedFile`/`uploadedFiles` fields without a nullness check, but 
`ActionFileUploadInterceptor`, in `struts2-core`, only ever assigns either field when at least one file was accepted 
from the multipart request -- leaving both fields `null` whenever the form is submitted without a file having been 
selected.  Importantly, `struts2-showcase` is "sample code" and contains cross-site scripting (XSS) and various other 
issues (OGNL injection, of course), but we felt it important to show the code so that others are aware of how the 
interceptor operates and to not use the sample code as any kind of a guide (for many reasons).

```java
    public Object getUploadedFile() {
        return uploadedFile.getContent();
    }
```
Code snippet from `struts2-showcase`'s 
apps/showcase/src/main/java/org/apache/struts2/showcase/fileupload/FileUploadAction.java, lines 66-68

```java
    public String upload() throws Exception {
        System.out.println("\n\n upload2");
        System.out.println("files:");
        for (UploadedFile u : uploadedFiles) {
            System.out.println("*** " + u + "\t" + u.length());
        }
```
Snippet from `struts2-showcase`'s 
apps/showcase/src/main/java/org/apache/struts2/showcase/fileupload/MultipleFileUploadUsingArrayAction.java, lines 41-45

```java
        if (acceptedFiles.isEmpty()) {
            LOG.debug("No files have been uploaded/accepted");
        } else {
            LOG.debug("Passing: {} uploaded file(s) to action", acceptedFiles.size());
            action.withUploadedFiles(acceptedFiles);
        }

        // invoke action
        return invocation.invoke();
```
Snippet from `struts2-core`'s core/src/main/java/org/apache/struts2/interceptor/ActionFileUploadInterceptor.java, lines 
278-286, showing both fields left unset whenever no files are accepted

SelectHandle -- Option Group Rendering Dereferences an Unresolved Lookup
`SelectHandler.writeOptionGroup()`, in `struts2-javatemplates-plugin`, calls `toString()` directly on the object 
returned by a value-stack lookup for a configured list-key or list-value property without a nullness check, even though 
the sibling top-level list-rendering code in the very same class already null-checks the identical lookup before 
calling `toString()` on it.

```java
                Object tmpKey = stack.findValue(listKey != null ? listKey : "top");
                String tmpKeyStr = StringUtils.defaultString(tmpKey.toString());
                Object tmpValue = stack.findValue(listValue != null ? listValue : "top");
                String tmpValueStr = StringUtils.defaultString(tmpValue.toString());
```
Code snippet from `struts2-javatemplates-plugin`'s 
plugins/javatemplates/src/main/java/org/apache/struts2/views/java/simple/SelectHandler.java, lines 135-138

```java
                //key
                Object itemKey = findValue(listKey != null ? listKey : "top");
                String itemKeyStr = StringUtils.defaultString(itemKey == null ? null : itemKey.toString());
                //value
                Object itemValue = findValue(listValue != null ? listValue : "top");
                String itemValueStr = StringUtils.defaultString(itemValue == null ? null : itemValue.toString());
```
Snippet from `struts2-javatemplates-plugin`'s 
plugins/javatemplates/src/main/java/org/apache/struts2/views/java/simple/SelectHandler.java, lines 82-87, showing the 
sibling null-guarded equivalent lookup

Accepted/Excluded Patterns Checker -- Unguarded Regex Match Against a Null Expression
`DefaultNotExcludedAcceptedPatternsChecker.isAllowed(String)`, `isAccepted(String)`, and `isExcluded(String)`, in 
`struts2-core`, forward their `value` parameter to `DefaultAcceptedPatternsChecker.isAccepted(String)` and 
`DefaultExcludedPatternsChecker.isExcluded(String)`, both of which call `pattern.matcher(value)` for every configured 
pattern without a nullness check.

```java
    @Override
    public IsAllowed isAllowed(String value) {
        IsExcluded isExcluded = isExcluded(value);
        if (isExcluded.isExcluded()) {
            return IsAllowed.no(isExcluded.getExcludedPattern());
        }

        IsAccepted isAccepted = isAccepted(value);
        if (!isAccepted.isAccepted()) {
            return IsAllowed.no(isAccepted.getAcceptedPattern());
        }

        return IsAllowed.yes(isAccepted.getAcceptedPattern());
    }

    @Override
    public IsAccepted isAccepted(String value) {
        return acceptedPatterns.isAccepted(value);
    }
```
Code snippet from `struts2-core`'s 
core/src/main/java/org/apache/struts2/security/DefaultNotExcludedAcceptedPatternsChecker.java, lines 41-59, showing 
`isAllowed(String)` and `isAccepted(String)` forwarding `value` onward without protecting against `null`s

```java
    @Override
    public IsExcluded isExcluded(String value) {
        return excludedPatterns.isExcluded(value);
    }
```
Snippet from `struts2-core`'s 
core/src/main/java/org/apache/struts2/security/DefaultNotExcludedAcceptedPatternsChecker.java, lines 81-84, showing 
`isExcluded(String)`similarly  forwarding `value`

```java
    @Override
    public IsAccepted isAccepted(String value) {
        for (Pattern acceptedPattern : acceptedPatterns) {
            if (acceptedPattern.matcher(value).matches()) {
                LOG.trace("[{}] matches accepted pattern [{}]", value, acceptedPattern);
                return IsAccepted.yes(acceptedPattern.toString());
            }
        }
        return IsAccepted.no(acceptedPatterns.toString());
    }
```
Snippet from `struts2-core`'s core/src/main/java/org/apache/struts2/security/DefaultAcceptedPatternsChecker.java, lines 
122-131, showing `isAccepted(String)`'s unconditional `pattern.matcher(value)` call

```java
    @Override
    public IsExcluded isExcluded(String value) {
        for (Pattern excludedPattern : excludedPatterns) {
            if (excludedPattern.matcher(value).matches()) {
                LOG.trace("[{}] matches excluded pattern [{}]", value, excludedPattern);
                return IsExcluded.yes(excludedPattern);
            }
        }
        return IsExcluded.no(excludedPatterns);
    }
```
Snippet from `struts2-core`'s core/src/main/java/org/apache/struts2/security/DefaultExcludedPatternsChecker.java, lines 
106-115, showing `isExcluded(String)`'s identical behaviour

DefaultTextProvider -- Null Default Value Omitted From the String-Array-Args Overload's Null Guard
`DefaultTextProvider`'s `List<?>`-args overload of `getText(String, String, List<?>)`, in `struts2-core`, explicitly 
substitutes `key` for `defaultValue` whenever both the bundle lookup and the caller-supplied default are `null`, so 
`new MessageFormat()` never receives a `null` pattern, but the otherwise-parallel `String[]`-args overload omits that 
same check entirely, so an identical bundle miss combined with a `null` `defaultValue` reaches `new 
MessageFormat(defaultValue)`, after which an exception will be thrown.

```java
    @Override
    public String getText(String key, String defaultValue, List<?> args) {
        String text = getText(key, args);
        if(text == null && defaultValue == null) {
            defaultValue = key;
        }
        if (text == null && defaultValue != null) {

            MessageFormat format = new MessageFormat(defaultValue);
            format.setLocale(ActionContext.getContext().getLocale());
            format.applyPattern(defaultValue);

            Object[] params;
            if (args != null) {
                params = args.toArray();
            } else {
                params = EMPTY_ARGS;
            }

            return format.format(params);
        }
        return text;
    }
```
Code snippet from `struts2-core`'s core/src/main/java/org/apache/struts2/text/DefaultTextProvider.java, lines 91-113, 
showing the `List<?>`-args overload's `text == null && defaultValue == null` substitution

```java
    @Override
    public String getText(String key, String defaultValue, String[] args) {
        String text = getText(key, args);
        if (text == null) {
            MessageFormat format = new MessageFormat(defaultValue);
            format.setLocale(ActionContext.getContext().getLocale());
            format.applyPattern(defaultValue);

            return format.format(requireNonNullElse(args, EMPTY_ARGS));

        }
        return text;
    }
```
Snippet from `struts2-core`'s core/src/main/java/org/apache/struts2/text/DefaultTextProvider.java, lines 115-127, 
showing the sibling `String[]`-args overload reaching `new MessageFormat(defaultValue)` without an equivalent guard

Steps to Reproduce
The following are various snippets, etc., that will allow you to reproduce some of the above.  You can easily make 
sample Apache Struts2 applications that prove each of these, but, for the sake of brevity, we will show you two harness 
runs against the code, directly.  Enjoy.

Range Validator Instance
```java
static void runCase(String label, Integer[] values) {
    ArrayFieldStub validator = new ArrayFieldStub(values);
    validator.setMin(1);
    validator.setMax(100);
    try {
        validator.validate(new Object());
        System.out.println(label + ":NO_EXCEPTION");
    } catch (Throwable e) {
        StackTraceElement top = e.getStackTrace().length > 0 ? e.getStackTrace()[0] : null;
        System.out.println(label + ":EXCEPTION:" + e.getClass().getName() + ":" + e.getMessage()
            + ":TOP_FRAME:" + (top != null ? top.getClassName() + "." + top.getMethodName() + ":" + top.getLineNumber() 
: "none"));
    }
}
```
Excerpt from the probe, running the NULL_ELEMENT case (stub array {5, null, 15}) against the ALL_VALID negative control 
({5, 8, 9}), both with min=1/max=100

```text
VULNERABLE -- an Integer[] containing one null element ({5, null, 15}) with min=1/max=100 configured threw
an uncaught java.lang.NullPointerException whose top stack frame is
'org.apache.struts2.validator.validators.RangeValidatorSupport.validateValue:77'
while the byte-identical in-range, null-free array {5, 8, 9} returned normally without an exception
```
A run of the harness shows it vulnerable with the control passing and the test failing

Double Range Validator Instance
```java
public static void main(String[] args) {
    runCase("NULL_ELEMENT_ARRAY", new Object[]{"5.0", null, "15.0"});
    runCase("ALL_VALID_ARRAY", new Object[]{"5.0", "8.0", "9.0"});
    runCase("EMPTY_STRING_ELEMENT_ARRAY", new Object[]{"5.0", "", "9.0"});
    runCase("NULL_ELEMENT_COLLECTION", Arrays.asList("5.0", null, "15.0"));
    runCase("ALL_VALID_COLLECTION", Arrays.asList("5.0", "8.0", "9.0"));
}
```
Excerpt from the probe's `main()` method, exercising the array branch (`NULL_ELEMENT_ARRAY` against the 
`ALL_VALID_ARRAY` and `EMPTY_STRING_ELEMENT_ARRAY` controls) and the `Collection` branch (`NULL_ELEMENT_COLLECTION` 
against the `ALL_VALID_COLLECTION` control), all with `minInclusive=1.0`/`maxInclusive=100.0`

```text
NULL_ELEMENT_ARRAY:EXCEPTION:java.lang.NullPointerException:Cannot invoke "Object.toString()" because "obj" is 
null:TOP_FRAME:org.apache.struts2.validator.validators.DoubleRangeFieldValidator.validateValue:141
ALL_VALID_ARRAY:NO_EXCEPTION
EMPTY_STRING_ELEMENT_ARRAY:NO_EXCEPTION
NULL_ELEMENT_COLLECTION:EXCEPTION:java.lang.NullPointerException:Cannot invoke "Object.toString()" because "obj" is 
null:TOP_FRAME:org.apache.struts2.validator.validators.DoubleRangeFieldValidator.validateValue:141
ALL_VALID_COLLECTION:NO_EXCEPTION
```
A run of the harness shows it vulnerable with the control passing and the test failing
_______________________________________________
Sent through the Full Disclosure mailing list
https://nmap.org/mailman/listinfo/fulldisclosure
Web Archives & RSS: https://seclists.org/fulldisclosure/