# V5615. OWASP. Potential XEE vulnerability. Insecure XML parser is used to process potentially tainted data.

- What is an XEE attack?
- Vulnerable code examples

The analyzer has detected the use of an insecurely configured XML parser that processes external data. This can make an application vulnerable to an XEE attack (also called a 'billion laughs' attack or an XML bombs attack).

XEE attacks are included in OWASP Top 10 2017: A4:2017 – XML External Entities (XXE), and OWASP Top 10 2021: A05:2021 – Security Misconfiguration.

## What is an XEE attack?

XML files may contain the document type definition (DTD). DTD allows us to define and use XML entities. Entities can either refer to some external resource or be fully defined inside the document. In the latter case, they can be represented by a string or other entities, for example.

An XML file with examples of such entities:

    <?xml version="1.0" encoding="utf-8" ?>
    <!DOCTYPE foo [
      <!ENTITY lol "lol">
      <!ENTITY lol1 "&lol;&lol;">
    ]>
    <foo>&lol1;</foo>

The file contains the 'lol' and 'lol1' entities. We define the first one through a string, and the second one through other entities. The value of the 'lol1' entity results in the 'lollol' string.

We can increase the nesting and the number of entities. For example:

    <?xml version="1.0" encoding="utf-8" ?>
    <!DOCTYPE foo [
      <!ENTITY lol "lol">
      <!ENTITY lol1 "&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;">
      <!ENTITY lol2 "&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;">
    ]>
    <foo>&lol2;</foo>

The 'lol2' entity expands as follows:

    lollollollollollollollollollollollollollollollollollollollollollollol
    lollollollollollollollollollollollollollollollollollollollollollollol
    lollollollollollollollollollollollollollollollollollollollollollollol
    lollollollollollollollollollollollollollollollollollollollollollollol
    lollollollollollollollol

So-called XML bombs are created in a similar way, by increasing the number of nested entities. XML bombs are small files that enlarge when entities are expanded. That's where this type of attack got its name:

- XEE (XML Entity Expansion)
- billion laughs (because of a multiple repetition of 'lol').

Thus, a hacker can perform a DoS attack with XML bombs if:

- an attacker can pass an XML bomb to an application;
- an XML parser that processes this file has an insecure configuration.

You can read about a real-world example of an application vulnerability to XEE in the article: "How Visual Studio 2022 ate up 100 GB of memory and what XML bombs had to do with it".

## Vulnerable code examples

Look at the example:

    static void XEETarget(String pathToXml)
    {
      XmlReaderSettings settings = new XmlReaderSettings()
      {
        DtdProcessing = DtdProcessing.Parse,
        MaxCharactersFromEntities = 0
      };

      using (var xml = File.OpenRead(pathToXml))
      {
        using (var reader = XmlReader.Create(xml, settings))
        {
          while (reader.Read())
          {
            if (reader.NodeType == XmlNodeType.Text)
              Console.WriteLine(reader.Value);
          }
        }
      }
    }

In this example, the 'reader' object parses an XML file. However, this parser is vulnerable to XML bombs because it was created with insecure settings, where:

- the DTD processing is allowed. The 'DtdProcessing' property has the 'DtdProcessing.Parse' value;
- the developer didn't set limits on the size of entities. The 'MaxCharactersFromEntities' property is set to 0.

As a result, the parser may freeze trying to parse an XML bomb and start consuming a large amount of memory.

Note that the processed data comes from an external source — they are read from the file along 'pathToXml'. The analyzer detects a combination of these factors and issues a warning.

If we want to make a parser resistant to XEE attacks, we can:

- prohibit or ignore DTD processing — set the 'Prohibit' / 'Ignore' value for the 'DtdProcessing' property. In older .NET Framework versions, the 'ProhibitDtd' property is used instead of 'DtdProcessing'. 'ProhibitDtd' must have the 'true' value to prohibit the DTD processing.
- set limits on the maximum size of entities.

Below is an example of settings in which the DTD processing is allowed, but the maximum size of entities is limited:

    XmlReaderSettings settings = new XmlReaderSettings()
    {
      DtdProcessing = DtdProcessing.Parse,
      MaxCharactersFromEntities = 1024
    };

If the size of entities exceeds the limits during the XML file parsing, the 'reader' parser generates an exception of the 'XmlException' type.

The analyzer also takes into account interprocedural calls. Let's change the example above:

    static XmlReaderSettings GetDefaultSettings()
    {
      var settings = new XmlReaderSettings();
      settings.DtdProcessing = DtdProcessing.Parse;
      settings.MaxCharactersFromEntities = 0;

      return settings;
    }

    public static void XEETarget(String pathToXml)
    {
      using (var xml = File.OpenRead(pathToXml))
      {
        using (var reader = XmlReader.Create(xml, GetDefaultSettings()))
        {
          ProcessXml(reader);
        }
      }
    }

    static void ProcessXml(XmlReader reader)
    {
      while (reader.Read())
      {
        // Process XML
      }
    }

In this case the analyzer issues a warning for calling the 'ProcessXml' method, since it tracks that:

- the XML file is processed inside 'ProcessXml';
- the developer created the XML parser with insecure settings came from the 'GetDefaultSettings' method;
- the parser processes potentially tainted data (read from the 'pathToXml' file).

Besides, the analyzer points out the code fragments corresponding to the actions listed above.

Note that the analyzer also sees method parameters (available from other assemblies) as tainted data sources. You can read more about it in the article: "Why you should check values of public methods' parameters".

Example:

    public class XEETest
    {
      public static void XEETarget(Stream xmlStream)
      {
        var rs = new XmlReaderSettings()
        {
          DtdProcessing = DtdProcessing.Parse,
          MaxCharactersFromEntities = 0
        };

        using (var reader = XmlReader.Create(xmlStream, rs))
        {
          while (reader.Read())
          {
            // Process XML
          }
        }
      }
    }

The analyzer issues a low certainty level warning for this code, since the source of tainted data – a parameter of a publicly available method – is used in a dangerously configured XML parser.

Note that in different .NET Framework versions default settings may vary. Therefore, the same code fragment may be vulnerable to XEE attacks, or be resistant.

An example of this fragment:

    static void XEETarget(String pathToXml)
    {
      using (var xml = File.OpenRead(pathToXml))
      {
        var settings = new XmlReaderSettings()
        {
          DtdProcessing = DtdProcessing.Parse
        };

        using (var reader = XmlReader.Create(xml, settings))
        {
          while (reader.Read())
          {
            // Process XML
          }
        }
      }
    }

This code fragment is vulnerable to XEE attacks in .NET Framework 4.5.1 and older versions. It does not set limits on entities size — the value of the 'MaxCharactersFromEntities' property is 0. In .NET Framework 4.5.2 and newer versions a limit on entities size is set by default. As a result, this code fragment is resistant to XEE attacks.

This diagnostic is classified as:

CWE-776