Hello community, here is the log from the commit of package libqt4 for openSUSE:Factory checked in at 2014-01-16 15:37:54 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/libqt4 (Old) and /work/SRC/openSUSE:Factory/.libqt4.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "libqt4" Changes: -------- libqt4-sql-plugins.changes: same change --- /work/SRC/openSUSE:Factory/libqt4/libqt4.changes 2013-12-11 11:28:54.000000000 +0100 +++ /work/SRC/openSUSE:Factory/.libqt4.new/libqt4.changes 2014-01-23 15:48:15.000000000 +0100 @@ -1,0 +2,7 @@ +Tue Jan 7 13:48:11 UTC 2014 - [email protected] + +- add 0001-Disallow-deep-or-widely-nested-entity-references.patch, + 0001-Fully-expand-entities-to-ensure-deep-or-widely-neste.patch + (bnc#856832, CVE-2013-4549) + +------------------------------------------------------------------- New: ---- 0001-Disallow-deep-or-widely-nested-entity-references.patch 0001-Fully-expand-entities-to-ensure-deep-or-widely-neste.patch ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ libqt4-devel-doc.spec ++++++ --- /var/tmp/diff_new_pack.eu26y9/_old 2014-01-23 15:48:19.000000000 +0100 +++ /var/tmp/diff_new_pack.eu26y9/_new 2014-01-23 15:48:19.000000000 +0100 @@ -1,7 +1,7 @@ # # spec file for package libqt4-devel-doc # -# Copyright (c) 2013 SUSE LINUX Products GmbH, Nuernberg, Germany. +# Copyright (c) 2014 SUSE LINUX Products GmbH, Nuernberg, Germany. # # All modifications and additions to the file contributed by third parties # remain the property of their copyright owners, unless otherwise agreed @@ -114,6 +114,8 @@ # PATCH-FIX-UPSTREAM 0006-Revert-QTBUG-15319-fix-shortcuts-with-secondary-Xkb-layout.patch (QTBUG#32908) Patch159: 0006-Revert-QTBUG-15319-fix-shortcuts-with-secondary-Xkb-layout.patch Patch160: ppc64le.diff +Patch161: 0001-Disallow-deep-or-widely-nested-entity-references.patch +Patch162: 0001-Fully-expand-entities-to-ensure-deep-or-widely-neste.patch BuildRoot: %{_tmppath}/%{name}-%{version}-build %define common_options --opensource -fast -no-separate-debug-info -shared -xkb -openssl-linked -xrender -xcursor -dbus-linked -xfixes -xrandr -xinerama -sm -no-nas-sound -no-rpath -system-libjpeg -system-libpng -accessibility -cups -stl -nis -system-zlib -prefix /usr -L %{_libdir} -libdir %{_libdir} -docdir %_docdir/%{base_name} -examplesdir %{_libdir}/qt4/examples -demosdir %{_libdir}/qt4/demos -plugindir %plugindir -translationdir %{_datadir}/qt4/translations -iconv -sysconfdir /etc/settings -datadir %{_datadir}/qt4/ -no-pch -reduce-relocations -exceptions -system-libtiff -glib -optimized-qmake -no-webkit -no-xmlpatterns -system-sqlite -qt3support -no-sql-mysql -importdir %plugindir/imports -xsync -xinput -gtkstyle %define check_config \ @@ -197,6 +199,8 @@ %patch158 -p1 %patch159 -p1 %patch160 +%patch161 -p1 +%patch162 -p1 # ### 47 rediff #%patch121 -p1 # be sure not to use them libqt4-sql-plugins.spec: same change libqt4.spec: same change ++++++ 0001-Disallow-deep-or-widely-nested-entity-references.patch ++++++ >From 512a1ce0698d370c313bb561bbf078935fa0342e Mon Sep 17 00:00:00 2001 From: Mitch Curtis <[email protected]> Date: Thu, 7 Nov 2013 09:36:29 +0100 Subject: [PATCH] Disallow deep or widely nested entity references. Nested references with a depth of 2 or greater will fail. References that partially expand to greater than 1024 characters will also fail. This is a backport of 46a8885ae486e238a39efa5119c2714f328b08e4. Change-Id: I0c2e1fa13d6ccb5f88641dae2ed3f28bfdeaf609 Reviewed-by: Richard J. Moore <[email protected]> Reviewed-by: Lars Knoll <[email protected]> --- src/xml/sax/qxml.cpp | 51 +++++++++++++++++++ .../auto/qxmlsimplereader/tst_qxmlsimplereader.cpp | 58 ++++++++++++++++++++++ .../xmldocs/1-levels-nested-dtd.xml | 12 +++++ .../xmldocs/2-levels-nested-dtd.xml | 13 +++++ .../internal-entity-polynomial-attribute.xml | 13 +++++ 5 files changed, 147 insertions(+) create mode 100644 tests/auto/qxmlsimplereader/xmldocs/1-levels-nested-dtd.xml create mode 100644 tests/auto/qxmlsimplereader/xmldocs/2-levels-nested-dtd.xml create mode 100644 tests/auto/qxmlsimplereader/xmldocs/internal-entity-polynomial-attribute.xml diff --git a/src/xml/sax/qxml.cpp b/src/xml/sax/qxml.cpp index a1777c5..3904632 100644 --- a/src/xml/sax/qxml.cpp +++ b/src/xml/sax/qxml.cpp @@ -424,6 +424,10 @@ private: int stringValueLen; QString emptyStr; + // The limit to the amount of times the DTD parsing functions can be called + // for the DTD currently being parsed. + int dtdRecursionLimit; + const QString &string(); void stringClear(); void stringAddC(QChar); @@ -492,6 +496,7 @@ private: void unexpectedEof(ParseFunction where, int state); void parseFailed(ParseFunction where, int state); void pushParseState(ParseFunction function, int state); + bool isPartiallyExpandedEntityValueTooLarge(QString *errorMessage); Q_DECLARE_PUBLIC(QXmlSimpleReader) QXmlSimpleReader *q_ptr; @@ -2759,6 +2764,7 @@ QXmlSimpleReaderPrivate::QXmlSimpleReaderPrivate(QXmlSimpleReader *reader) useNamespacePrefixes = false; reportWhitespaceCharData = true; reportEntities = false; + dtdRecursionLimit = 2; } QXmlSimpleReaderPrivate::~QXmlSimpleReaderPrivate() @@ -5018,6 +5024,11 @@ bool QXmlSimpleReaderPrivate::parseDoctype() } break; case Mup: + if (dtdRecursionLimit > 0 && parameterEntities.size() > dtdRecursionLimit) { + reportParseError(QString::fromLatin1( + "DTD parsing exceeded recursion limit of %1.").arg(dtdRecursionLimit)); + return false; + } if (!parseMarkupdecl()) { parseFailed(&QXmlSimpleReaderPrivate::parseDoctype, state); return false; @@ -6627,6 +6638,37 @@ bool QXmlSimpleReaderPrivate::parseChoiceSeq() return false; } +bool QXmlSimpleReaderPrivate::isPartiallyExpandedEntityValueTooLarge(QString *errorMessage) +{ + const QString value = string(); + QMap<QString, int> referencedEntityCounts; + foreach (QString entityName, entities.keys()) { + for (int i = 0; i < value.size() && i != -1; ) { + i = value.indexOf(entityName, i); + if (i != -1) { + // The entityName we're currently trying to find + // was matched in this string; increase our count. + ++referencedEntityCounts[entityName]; + i += entityName.size(); + } + } + } + + foreach (QString entityName, referencedEntityCounts.keys()) { + const int timesReferenced = referencedEntityCounts[entityName]; + const QString entityValue = entities[entityName]; + if (entityValue.size() * timesReferenced > 1024) { + if (errorMessage) { + *errorMessage = QString::fromLatin1("The XML entity \"%1\"" + "expands too a string that is too large to process when " + "referencing \"%2\" %3 times.").arg(entityName).arg(entityName).arg(timesReferenced); + } + return true; + } + } + return false; +} + /* Parse a EntityDecl [70]. @@ -6721,6 +6763,15 @@ bool QXmlSimpleReaderPrivate::parseEntityDecl() switch (state) { case EValue: if ( !entityExist(name())) { + QString errorMessage; + if (isPartiallyExpandedEntityValueTooLarge(&errorMessage)) { + // The entity at entityName is entityValue.size() characters + // long in its unexpanded form, and was mentioned timesReferenced times, + // resulting in a string that would be greater than 1024 characters. + reportParseError(errorMessage); + return false; + } + entities.insert(name(), string()); if (declHnd) { if (!declHnd->internalEntityDecl(name(), string())) { ++++++ 0001-Fully-expand-entities-to-ensure-deep-or-widely-neste.patch ++++++ >From cecceb0cdd87482124a73ecf537f3445d68be13e Mon Sep 17 00:00:00 2001 From: Mitch Curtis <[email protected]> Date: Tue, 12 Nov 2013 13:44:56 +0100 Subject: [PATCH] Fully expand entities to ensure deep or widely nested ones fail parsing With 512a1ce0698d370c313bb561bbf078935fa0342e, we failed when parsing entities whose partially expanded size was greater than 1024 characters. That was not enough, so now we fully expand all entities. This is a backport of f1053d94f59f053ce4acad9320df14f1fbe4faac. Change-Id: I41dd6f4525c63e82fd320a22d19248169627f7e0 Reviewed-by: Richard J. Moore <[email protected]> --- src/xml/sax/qxml.cpp | 61 +++++++++++++--------- .../auto/qxmlsimplereader/tst_qxmlsimplereader.cpp | 2 +- 2 files changed, 37 insertions(+), 26 deletions(-) diff --git a/src/xml/sax/qxml.cpp b/src/xml/sax/qxml.cpp index 3904632..befa801 100644 --- a/src/xml/sax/qxml.cpp +++ b/src/xml/sax/qxml.cpp @@ -426,7 +426,9 @@ private: // The limit to the amount of times the DTD parsing functions can be called // for the DTD currently being parsed. - int dtdRecursionLimit; + static const int dtdRecursionLimit = 2; + // The maximum amount of characters an entity value may contain, after expansion. + static const int entityCharacterLimit = 1024; const QString &string(); void stringClear(); @@ -496,7 +498,7 @@ private: void unexpectedEof(ParseFunction where, int state); void parseFailed(ParseFunction where, int state); void pushParseState(ParseFunction function, int state); - bool isPartiallyExpandedEntityValueTooLarge(QString *errorMessage); + bool isExpandedEntityValueTooLarge(QString *errorMessage); Q_DECLARE_PUBLIC(QXmlSimpleReader) QXmlSimpleReader *q_ptr; @@ -2764,7 +2766,6 @@ QXmlSimpleReaderPrivate::QXmlSimpleReaderPrivate(QXmlSimpleReader *reader) useNamespacePrefixes = false; reportWhitespaceCharData = true; reportEntities = false; - dtdRecursionLimit = 2; } QXmlSimpleReaderPrivate::~QXmlSimpleReaderPrivate() @@ -6638,30 +6639,43 @@ bool QXmlSimpleReaderPrivate::parseChoiceSeq() return false; } -bool QXmlSimpleReaderPrivate::isPartiallyExpandedEntityValueTooLarge(QString *errorMessage) +bool QXmlSimpleReaderPrivate::isExpandedEntityValueTooLarge(QString *errorMessage) { - const QString value = string(); - QMap<QString, int> referencedEntityCounts; - foreach (QString entityName, entities.keys()) { - for (int i = 0; i < value.size() && i != -1; ) { - i = value.indexOf(entityName, i); - if (i != -1) { - // The entityName we're currently trying to find - // was matched in this string; increase our count. - ++referencedEntityCounts[entityName]; - i += entityName.size(); + QMap<QString, int> literalEntitySizes; + // The entity at (QMap<QString,) referenced the entities at (QMap<QString,) (int>) times. + QMap<QString, QMap<QString, int> > referencesToOtherEntities; + QMap<QString, int> expandedSizes; + + // For every entity, check how many times all entity names were referenced in its value. + foreach (QString toSearch, entities.keys()) { + // The amount of characters that weren't entity names, but literals, like 'X'. + QString leftOvers = entities.value(toSearch); + // How many times was entityName referenced by toSearch? + foreach (QString entityName, entities.keys()) { + for (int i = 0; i < leftOvers.size() && i != -1; ) { + i = leftOvers.indexOf(QString::fromLatin1("&%1;").arg(entityName), i); + if (i != -1) { + leftOvers.remove(i, entityName.size() + 2); + // The entityName we're currently trying to find was matched in this string; increase our count. + ++referencesToOtherEntities[toSearch][entityName]; + } } } + literalEntitySizes[toSearch] = leftOvers.size(); } - foreach (QString entityName, referencedEntityCounts.keys()) { - const int timesReferenced = referencedEntityCounts[entityName]; - const QString entityValue = entities[entityName]; - if (entityValue.size() * timesReferenced > 1024) { + foreach (QString entity, referencesToOtherEntities.keys()) { + expandedSizes[entity] = literalEntitySizes[entity]; + foreach (QString referenceTo, referencesToOtherEntities.value(entity).keys()) { + const int references = referencesToOtherEntities.value(entity).value(referenceTo); + // The total size of an entity's value is the expanded size of all of its referenced entities, plus its literal size. + expandedSizes[entity] += expandedSizes[referenceTo] * references + literalEntitySizes[referenceTo] * references; + } + + if (expandedSizes[entity] > entityCharacterLimit) { if (errorMessage) { - *errorMessage = QString::fromLatin1("The XML entity \"%1\"" - "expands too a string that is too large to process when " - "referencing \"%2\" %3 times.").arg(entityName).arg(entityName).arg(timesReferenced); + *errorMessage = QString::fromLatin1("The XML entity \"%1\" expands too a string that is too large to process (%2 characters > %3)."); + *errorMessage = (*errorMessage).arg(entity).arg(expandedSizes[entity]).arg(entityCharacterLimit); } return true; } @@ -6764,10 +6778,7 @@ bool QXmlSimpleReaderPrivate::parseEntityDecl() case EValue: if ( !entityExist(name())) { QString errorMessage; - if (isPartiallyExpandedEntityValueTooLarge(&errorMessage)) { - // The entity at entityName is entityValue.size() characters - // long in its unexpanded form, and was mentioned timesReferenced times, - // resulting in a string that would be greater than 1024 characters. + if (isExpandedEntityValueTooLarge(&errorMessage)) { reportParseError(errorMessage); return false; } -- To unsubscribe, e-mail: [email protected] For additional commands, e-mail: [email protected]
