From 23a43df6fb5d3928c66f90d5c4475bca15694673 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jonas=20Sch=C3=A4fer?= Date: Mon, 10 Jan 2022 18:23:54 +0100 Subject: util.xml: Do not allow doctypes, comments or processing instructions Yes. This is as bad as it sounds. CVE pending. In Prosody itself, this only affects mod_websocket, which uses util.xml to parse the frame, thus allowing unauthenticated remote DoS using Billion Laughs. However, third-party modules using util.xml may also be affected by this. This commit installs handlers which disallow the use of doctype declarations and processing instructions without any escape hatch. It, by default, also introduces such a handler for comments, however, there is a way to enable comments nontheless. This is because util.xml is used to parse human-facing data, where comments are generally a desirable feature, and also because comments are generally harmless. --- spec/util_xml_spec.lua | 34 +++++++++++++++++++++++++++++++++- util/xml.lua | 25 +++++++++++++++++++++++-- 2 files changed, 56 insertions(+), 3 deletions(-) diff --git a/spec/util_xml_spec.lua b/spec/util_xml_spec.lua index 11820894..28a1cea7 100644 --- a/spec/util_xml_spec.lua +++ b/spec/util_xml_spec.lua @@ -12,9 +12,41 @@ describe("util.xml", function() ]] - local stanza = xml.parse(x); + local stanza = xml.parse(x, {allow_comments = true}); assert.are.equal(stanza.tags[2].attr.xmlns, "b"); assert.are.equal(stanza.tags[2].namespaces["a"], "b"); end); + + it("should reject doctypes", function() + local x = ""; + local ok = xml.parse(x); + assert.falsy(ok); + end); + + it("should reject comments by default", function() + local x = ""; + local ok = xml.parse(x); + assert.falsy(ok); + end); + + it("should allow comments if asked nicely", function() + local x = ""; + local stanza = xml.parse(x, {allow_comments = true}); + assert.are.equal(stanza.name, "foo"); + assert.are.equal(#stanza, 0); + end); + + it("should reject processing instructions", function() + local x = ""; + local ok = xml.parse(x); + assert.falsy(ok); + end); + + it("should allow an xml declaration", function() + local x = ""; + local stanza = xml.parse(x); + assert.truthy(stanza); + assert.are.equal(stanza.name, "foo"); + end); end); end); diff --git a/util/xml.lua b/util/xml.lua index dac3f6fe..700da1d4 100644 --- a/util/xml.lua +++ b/util/xml.lua @@ -3,6 +3,7 @@ local st = require "util.stanza"; local lxp = require "lxp"; local t_insert = table.insert; local t_remove = table.remove; +local error = error; local _ENV = nil; -- luacheck: std none @@ -13,7 +14,7 @@ local parse_xml = (function() }; local ns_separator = "\1"; local ns_pattern = "^([^"..ns_separator.."]*)"..ns_separator.."?(.*)$"; - return function(xml) + return function(xml, options) --luacheck: ignore 212/self local handler = {}; local stanza = st.stanza("root"); @@ -64,7 +65,27 @@ local parse_xml = (function() function handler:EndElement() stanza:up(); end - local parser = lxp.new(handler, "\1"); + local parser; + -- SECURITY: These two handlers, especially the Doctype one, are required to prevent exploits such as Billion Laughs. + function handler:StartDoctypeDecl() + if not parser.stop or not parser:stop() then + error("Failed to abort parsing"); + end + end + function handler:ProcessingInstruction() + if not parser.stop or not parser:stop() then + error("Failed to abort parsing"); + end + end + if not options or not options.allow_comments then + -- NOTE: comments are generally harmless and can be useful when parsing configuration files or other data, even user-provided data + function handler:Comment() + if not parser.stop or not parser:stop() then + error("Failed to abort parsing"); + end + end + end + parser = lxp.new(handler, ns_separator); local ok, err, line, col = parser:parse(xml); if ok then ok, err, line, col = parser:parse(); end --parser:close(); -- cgit v1.2.3 -- cgit v1.2.3 From d17619344dda05f9bc9b3f98a0c82f2f68939605 Mon Sep 17 00:00:00 2001 From: Kim Alvefur Date: Thu, 20 Jan 2022 09:57:20 +0100 Subject: util.xml: Break reference to help the GC (fix #1711) LuaExpat uses a registry reference to track handlers, which makes it so that an upvalue like this creates a reference loop that keeps the parser and its handlers from being garbage collected. The same issue has affected util.xmppstream in the past. Code for checking: local xml_parse = require"util.xml".parse; for i = 1, 10000 do xml_parse("") end collectgarbage(); collectgarbage(); print(collectgarbage("count"), "KiB"); A future release of LuaExpat may fix the underlying issue there. --- util/xml.lua | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/util/xml.lua b/util/xml.lua index 700da1d4..72f1a26b 100644 --- a/util/xml.lua +++ b/util/xml.lua @@ -65,27 +65,26 @@ local parse_xml = (function() function handler:EndElement() stanza:up(); end - local parser; -- SECURITY: These two handlers, especially the Doctype one, are required to prevent exploits such as Billion Laughs. function handler:StartDoctypeDecl() - if not parser.stop or not parser:stop() then + if not self.stop or not self:stop() then error("Failed to abort parsing"); end end function handler:ProcessingInstruction() - if not parser.stop or not parser:stop() then + if not self.stop or not self:stop() then error("Failed to abort parsing"); end end if not options or not options.allow_comments then -- NOTE: comments are generally harmless and can be useful when parsing configuration files or other data, even user-provided data function handler:Comment() - if not parser.stop or not parser:stop() then + if not self.stop or not self:stop() then error("Failed to abort parsing"); end end end - parser = lxp.new(handler, ns_separator); + local parser = lxp.new(handler, ns_separator); local ok, err, line, col = parser:parse(xml); if ok then ok, err, line, col = parser:parse(); end --parser:close(); -- cgit v1.2.3 From 785d3273084026d308cfa92edf8832e24ec4193e Mon Sep 17 00:00:00 2001 From: Kim Alvefur Date: Thu, 20 Jan 2022 10:51:46 +0100 Subject: util.xml: Deduplicate handlers for restricted XML Makes the code more like util.xmppstream, allowing easier comparisons if we ever need to apply fixes in the future. --- util/xml.lua | 17 +++++------------ 1 file changed, 5 insertions(+), 12 deletions(-) diff --git a/util/xml.lua b/util/xml.lua index 72f1a26b..4327dfba 100644 --- a/util/xml.lua +++ b/util/xml.lua @@ -66,23 +66,16 @@ local parse_xml = (function() stanza:up(); end -- SECURITY: These two handlers, especially the Doctype one, are required to prevent exploits such as Billion Laughs. - function handler:StartDoctypeDecl() - if not self.stop or not self:stop() then - error("Failed to abort parsing"); - end - end - function handler:ProcessingInstruction() - if not self.stop or not self:stop() then + local function restricted_handler(parser) + if not parser.stop or not parser:stop() then error("Failed to abort parsing"); end end + handler.StartDoctypeDecl = restricted_handler; + handler.ProcessingInstruction = restricted_handler; if not options or not options.allow_comments then -- NOTE: comments are generally harmless and can be useful when parsing configuration files or other data, even user-provided data - function handler:Comment() - if not self.stop or not self:stop() then - error("Failed to abort parsing"); - end - end + handler.Comment = restricted_handler; end local parser = lxp.new(handler, ns_separator); local ok, err, line, col = parser:parse(xml); -- cgit v1.2.3