From 4201f1be45b4567ba64655439dcc39ac403c28e0 Mon Sep 17 00:00:00 2001

From: Michael Stahl <michael.stahl@allotropia.de>

Date: Fri, 12 Feb 2021 16:42:51 +0100

Subject: [PATCH 3/6] xmlsecurity: replace XSecParser implementation

MIME-Version: 1.0

Content-Type: text/plain; charset=UTF-8

Content-Transfer-Encoding: 8bit

Implement Namespaces in XML and follow xmldsig-core and XAdES schemas.

Reviewed-on: https://gerrit.libreoffice.org/c/core/+/110833

Tested-by: Jenkins

Reviewed-by: Michael Stahl <michael.stahl@allotropia.de>

(cherry picked from commit 12b15be8f4f930a04d8056b9219ac969b42a9784)

xmlsecurity: move XSecParser state into contexts

Reviewed-on: https://gerrit.libreoffice.org/c/core/+/111158

Tested-by: Jenkins

Reviewed-by: Michael Stahl <michael.stahl@allotropia.de>

(cherry picked from commit 59df9e70ce1a7ec797b836bda7f9642912febc53)

xmlsecurity: move XSecParser Reference state into contexts

Reviewed-on: https://gerrit.libreoffice.org/c/core/+/111159

Tested-by: Jenkins

Reviewed-by: Michael Stahl <michael.stahl@allotropia.de>

(cherry picked from commit cfeb89a758b5f0ec406f0d72444e52ed2f47b85e)

Reviewed-on: https://gerrit.libreoffice.org/c/core/+/111907

Tested-by: Jenkins

Reviewed-by: Caolán McNamara <caolanm@redhat.com>

(cherry picked from commit ad5930e87e788780a255523f106deb1dde5d7b37)

Change-Id: I03537b51bb757ecbfa63a826b38de543c70ba032

---

 include/xmloff/xmlimp.hxx                |    6 +-

 include/xmloff/xmlnmspe.hxx              |    7 +

 include/xmloff/xmltoken.hxx              |   13 +

 xmloff/source/core/xmlimp.cxx            |   26 +-

 xmloff/source/core/xmltoken.cxx          |   13 +

 xmloff/source/token/tokens.txt           |   10 +

 xmlsecurity/source/helper/xsecparser.cxx | 1629 +++++++++++++++++-----

 xmlsecurity/source/helper/xsecparser.hxx |   99 +-

 8 files changed, 1425 insertions(+), 378 deletions(-)

diff --git a/include/xmloff/xmlimp.hxx b/include/xmloff/xmlimp.hxx

index 6d0dda96596a..8d557789aa4c 100644

--- a/include/xmloff/xmlimp.hxx

+++ b/include/xmloff/xmlimp.hxx

@@ -229,8 +229,12 @@ class XMLOFF_DLLPUBLIC SvXMLImport : public cppu::WeakImplHelper<

     static void initializeNamespaceMaps();

     void registerNamespaces();

-    std::unique_ptr<SvXMLNamespaceMap> processNSAttributes(

+public:

+    static std::unique_ptr<SvXMLNamespaceMap> processNSAttributes(

+        std::unique_ptr<SvXMLNamespaceMap> & rpNamespaceMap,

+        SvXMLImport *const pImport,

         const css::uno::Reference< css::xml::sax::XAttributeList >& xAttrList);

+private:

     void Characters(const OUString& aChars);

     css::uno::Reference< css::task::XStatusIndicator > mxStatusIndicator;

diff --git a/include/xmloff/xmlnmspe.hxx b/include/xmloff/xmlnmspe.hxx

index b079053c38d3..302a134f92fe 100644

--- a/include/xmloff/xmlnmspe.hxx

+++ b/include/xmloff/xmlnmspe.hxx

@@ -66,6 +66,13 @@ XML_NAMESPACE( XML_NAMESPACE_OF,              34U )   // OpenFormula aka ODFF

 XML_NAMESPACE( XML_NAMESPACE_XHTML,           35U )

 XML_NAMESPACE( XML_NAMESPACE_GRDDL,           36U )

 XML_NAMESPACE( XML_NAMESPACE_VERSIONS_LIST,   37U )

+// OOo extension digital signatures, used in ODF 1.1

+XML_NAMESPACE( XML_NAMESPACE_DSIG_OOO,        38U )

+// ODF 1.2 digital signature namespaces

+XML_NAMESPACE( XML_NAMESPACE_DSIG,            39U )

+XML_NAMESPACE( XML_NAMESPACE_DS,              40U )

+XML_NAMESPACE( XML_NAMESPACE_XADES132,        41U )

+XML_NAMESPACE( XML_NAMESPACE_XADES141,        42U )

 // namespaces for odf extended formats

diff --git a/include/xmloff/xmltoken.hxx b/include/xmloff/xmltoken.hxx

index b5105e5da0f3..a0e52903060a 100644

--- a/include/xmloff/xmltoken.hxx

+++ b/include/xmloff/xmltoken.hxx

@@ -133,6 +133,19 @@ namespace xmloff { namespace token {

         XML_NP_GRDDL,

         XML_N_GRDDL,

+        // OOo extension digital signatures, used in ODF 1.1

+        XML_NP_DSIG_OOO,

+        XML_N_DSIG_OOO,

+        // ODF 1.2 digital signatures

+        XML_NP_DSIG,

+        XML_N_DSIG,

+        XML_NP_DS,

+        XML_N_DS,

+        XML_NP_XADES132,

+        XML_N_XADES132,

+        XML_NP_XADES141,

+        XML_N_XADES141,

+

         // ODF Enhanced namespaces

         XML_NP_OFFICE_EXT,

         XML_N_OFFICE_EXT,

diff --git a/xmloff/source/core/xmlimp.cxx b/xmloff/source/core/xmlimp.cxx

index ef63550ff2be..bfc9d3fe819a 100644

--- a/xmloff/source/core/xmlimp.cxx

+++ b/xmloff/source/core/xmlimp.cxx

@@ -653,6 +653,8 @@ void SAL_CALL SvXMLImport::endDocument()

 }

 std::unique_ptr<SvXMLNamespaceMap> SvXMLImport::processNSAttributes(

+        std::unique_ptr<SvXMLNamespaceMap> & rpNamespaceMap,

+        SvXMLImport *const pImport, // TODO???

         const uno::Reference< xml::sax::XAttributeList >& xAttrList)

 {

     std::unique_ptr<SvXMLNamespaceMap> pRewindMap;

@@ -660,12 +662,13 @@ std::unique_ptr<SvXMLNamespaceMap> SvXMLImport::processNSAttributes(

     for( sal_Int16 i=0; i < nAttrCount; i++ )

     {

         const OUString& rAttrName = xAttrList->getNameByIndex( i );

-        if ( rAttrName == "office:version" )

+        if (pImport && rAttrName == "office:version")

         {

-            mpImpl->aODFVersion = xAttrList->getValueByIndex( i );

+            pImport->mpImpl->aODFVersion = xAttrList->getValueByIndex( i );

             // the ODF version in content.xml and manifest.xml must be the same starting from ODF1.2

-            if ( mpImpl->mStreamName == "content.xml" && !IsODFVersionConsistent( mpImpl->aODFVersion ) )

+            if (pImport->mpImpl->mStreamName == "content.xml"

+                && !pImport->IsODFVersionConsistent(pImport->mpImpl->aODFVersion))

             {

                 throw xml::sax::SAXException("Inconsistent ODF versions in content.xml and manifest.xml!",

                         uno::Reference< uno::XInterface >(),

@@ -679,8 +682,8 @@ std::unique_ptr<SvXMLNamespaceMap> SvXMLImport::processNSAttributes(

         {

             if( !pRewindMap )

             {

-                pRewindMap = std::move(mpNamespaceMap);

-                mpNamespaceMap.reset(new SvXMLNamespaceMap(*pRewindMap));

+                pRewindMap = std::move(rpNamespaceMap);

+                rpNamespaceMap.reset(new SvXMLNamespaceMap(*pRewindMap));

             }

             const OUString& rAttrValue = xAttrList->getValueByIndex( i );

@@ -688,18 +691,18 @@ std::unique_ptr<SvXMLNamespaceMap> SvXMLImport::processNSAttributes(

                                  ? OUString()

                                  : rAttrName.copy( 6 ) );

             // Add namespace, but only if it is known.

-            sal_uInt16 nKey = mpNamespaceMap->AddIfKnown( aPrefix, rAttrValue );

+            sal_uInt16 nKey = rpNamespaceMap->AddIfKnown( aPrefix, rAttrValue );

             // If namespace is unknown, try to match a name with similar

             // TC Id and version

             if( XML_NAMESPACE_UNKNOWN == nKey  )

             {

                 OUString aTestName( rAttrValue );

                 if( SvXMLNamespaceMap::NormalizeURI( aTestName ) )

-                    nKey = mpNamespaceMap->AddIfKnown( aPrefix, aTestName );

+                    nKey = rpNamespaceMap->AddIfKnown( aPrefix, aTestName );

             }

             // If that namespace is not known, too, add it as unknown

             if( XML_NAMESPACE_UNKNOWN == nKey  )

-                mpNamespaceMap->Add( aPrefix, rAttrValue );

+                rpNamespaceMap->Add( aPrefix, rAttrValue );

         }

     }

@@ -712,7 +715,8 @@ void SAL_CALL SvXMLImport::startElement( const OUString& rName,

     //    SAL_INFO("svg", "startElement " << rName);

     // Process namespace attributes. This must happen before creating the

     // context, because namespace declaration apply to the element name itself.

-    std::unique_ptr<SvXMLNamespaceMap> pRewindMap(processNSAttributes(xAttrList));

+    std::unique_ptr<SvXMLNamespaceMap> pRewindMap(

+        processNSAttributes(mpNamespaceMap, this, xAttrList));

     // Get element's namespace and local name.

     OUString aLocalName;

@@ -885,7 +889,7 @@ void SAL_CALL SvXMLImport::startFastElement (sal_Int32 Element,

         maNamespaceHandler->addNSDeclAttributes( maNamespaceAttrList );

         std::unique_ptr<SvXMLNamespaceMap> pRewindMap(

-                processNSAttributes( maNamespaceAttrList.get() ));

+            processNSAttributes(mpNamespaceMap, this, maNamespaceAttrList.get()));

         assert( dynamic_cast<SvXMLImportContext*>( xContext.get() ) != nullptr );

         SvXMLImportContext *pContext = static_cast<SvXMLImportContext*>( xContext.get() );

         if (pRewindMap)

@@ -2231,7 +2235,7 @@ void SAL_CALL SvXMLLegacyToFastDocHandler::endDocument()

 void SAL_CALL SvXMLLegacyToFastDocHandler::startElement( const OUString& rName,

                         const uno::Reference< xml::sax::XAttributeList >& xAttrList )

 {

-    mrImport->processNSAttributes(xAttrList);

+    SvXMLImport::processNSAttributes(mrImport->mpNamespaceMap, mrImport.get(), xAttrList);

     OUString aLocalName;

     sal_uInt16 nPrefix = mrImport->mpNamespaceMap->GetKeyByAttrName( rName, &aLocalName );

     Sequence< sal_Int8 > aLocalNameSeq( reinterpret_cast<sal_Int8 const *>(

diff --git a/xmloff/source/core/xmltoken.cxx b/xmloff/source/core/xmltoken.cxx

index fb760c6307c5..13f1415b8cc4 100644

--- a/xmloff/source/core/xmltoken.cxx

+++ b/xmloff/source/core/xmltoken.cxx

@@ -137,6 +137,19 @@ namespace xmloff { namespace token {

         TOKEN( "grddl",                                 XML_NP_GRDDL ),

         TOKEN( "http://www.w3.org/2003/g/data-view#",   XML_N_GRDDL ),

+        // OOo extension digital signatures, used in ODF 1.1

+        TOKEN( "dsigooo", XML_NP_DSIG_OOO ),

+        TOKEN( "http://openoffice.org/2004/documentsignatures", XML_N_DSIG_OOO ),

+        // ODF 1.2 digital signature namespaces

+        TOKEN( "dsig", XML_NP_DSIG ),

+        TOKEN( "urn:oasis:names:tc:opendocument:xmlns:digitalsignature:1.0", XML_N_DSIG ),

+        TOKEN( "ds", XML_NP_DS ),

+        TOKEN( "http://www.w3.org/2000/09/xmldsig#", XML_N_DS ),

+        TOKEN( "xades132", XML_NP_XADES132 ),

+        TOKEN( "http://uri.etsi.org/01903/v1.3.2#", XML_N_XADES132 ),

+        TOKEN( "xades141", XML_NP_XADES141 ),

+        TOKEN( "http://uri.etsi.org/01903/v1.4.1#", XML_N_XADES141 ),

+

         // ODF Enhanced namespaces

         TOKEN( "officeooo", XML_NP_OFFICE_EXT ),

         TOKEN( "http://openoffice.org/2009/office", XML_N_OFFICE_EXT ),

diff --git a/xmloff/source/token/tokens.txt b/xmloff/source/token/tokens.txt

index 024877e8cf45..b2b95e956bd1 100644

--- a/xmloff/source/token/tokens.txt

+++ b/xmloff/source/token/tokens.txt

@@ -72,6 +72,16 @@ xhtml

 N_XHTML_DUMMY

 grddl

 N_GRDDL_DUMMY

+dsigooo

+N_DSIG_OOO_DUMMY

+dsig

+N_DSIG_DUMMY

+ds

+N_DS_DUMMY

+xades132

+N_XADES132_DUMMY

+xades141

+N_XADES141_DUMMY

 officeooo

 N_OFFICE_EXT_DUMMY

 formx

diff --git a/xmlsecurity/source/helper/xsecparser.cxx b/xmlsecurity/source/helper/xsecparser.cxx

index 82f347bff976..5c92e5efa104 100644

--- a/xmlsecurity/source/helper/xsecparser.cxx

+++ b/xmlsecurity/source/helper/xsecparser.cxx

@@ -21,6 +21,10 @@

 #include "xsecparser.hxx"

 #include <xsecctl.hxx>

 #include <xmlsignaturehelper.hxx>

+

+#include <xmloff/xmlnmspe.hxx>

+#include <xmloff/xmlimp.hxx>

+

 #include <com/sun/star/xml/sax/SAXException.hpp>

 #include <cppuhelper/exc_hlp.hxx>

 #include <sal/log.hxx>

@@ -29,471 +33,1460 @@ namespace cssu = com::sun::star::uno;

 namespace cssxc = com::sun::star::xml::crypto;

 namespace cssxs = com::sun::star::xml::sax;

-XSecParser::XSecParser(XMLSignatureHelper& rXMLSignatureHelper,

-    XSecController* pXSecController)

-    : m_bInX509IssuerName(false)

-    , m_bInX509SerialNumber(false)

-    , m_bInX509Certificate(false)

-    , m_bInGpgCertificate(false)

-    , m_bInGpgKeyID(false)

-    , m_bInGpgOwner(false)

-    , m_bInCertDigest(false)

-    , m_bInEncapsulatedX509Certificate(false)

-    , m_bInSigningTime(false)

-    , m_bInDigestValue(false)

-    , m_bInSignatureValue(false)

-    , m_bInDate(false)

-    , m_bInDescription(false)

-    , m_bInSignatureLineId(false)

-    , m_bInSignatureLineValidImage(false)

-    , m_bInSignatureLineInvalidImage(false)

-    , m_pXSecController(pXSecController)

-    , m_bReferenceUnresolved(false)

-    , m_nReferenceDigestID(cssxc::DigestID::SHA1)

-    , m_rXMLSignatureHelper(rXMLSignatureHelper)

+class XSecParser::Context

 {

-}

+    protected:

+        friend class XSecParser;

+        XSecParser & m_rParser;

+    private:

+        std::unique_ptr<SvXMLNamespaceMap> m_pOldNamespaceMap;

+

+    public:

+        Context(XSecParser & rParser,

+                std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap)

+            : m_rParser(rParser)

+            , m_pOldNamespaceMap(std::move(pOldNamespaceMap))

+        {

+        }

+

+        virtual ~Context() = default;

-OUString XSecParser::getIdAttr(const cssu::Reference< cssxs::XAttributeList >& xAttribs )

+        virtual void StartElement(

+            css::uno::Reference<css::xml::sax::XAttributeList> const& /*xAttrs*/)

+        {

+        }

+

+        virtual void EndElement()

+        {

+        }

+

+        virtual std::unique_ptr<Context> CreateChildContext(

+            std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap,

+            sal_uInt16 const /*nNamespace*/, OUString const& /*rName*/);

+

+        virtual void Characters(OUString const& /*rChars*/)

+        {

+        }

+};

+

+// it's possible that an unsupported element has an Id attribute and a

+// ds:Reference digesting it - probably this means XSecController needs to know

+// about it. (For known elements, the Id attribute is only processed according

+// to the schema.)

+class XSecParser::UnknownContext

+    : public XSecParser::Context

 {

-    OUString ouIdAttr = xAttribs->getValueByName("id");

+    public:

+        UnknownContext(XSecParser & rParser,

+                std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap)

+            : XSecParser::Context(rParser, std::move(pOldNamespaceMap))

+        {

+        }

-    if (ouIdAttr.isEmpty())

-    {

-        ouIdAttr = xAttribs->getValueByName("Id");

-    }

+        virtual void StartElement(

+            css::uno::Reference<css::xml::sax::XAttributeList> const& xAttrs) override

+        {

+            m_rParser.HandleIdAttr(xAttrs);

+        }

+};

-    return ouIdAttr;

+auto XSecParser::Context::CreateChildContext(

+    std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap,

+    sal_uInt16 const /*nNamespace*/, OUString const& /*rName*/)

+-> std::unique_ptr<Context>

+{

+    // default: create new base context

+    return std::make_unique<UnknownContext>(m_rParser, std::move(pOldNamespaceMap));

 }

-/*

- * XDocumentHandler

- */

-void SAL_CALL XSecParser::startDocument(  )

+class XSecParser::LoPGPOwnerContext

+    : public XSecParser::Context

 {

-    m_bInX509IssuerName = false;

-    m_bInX509SerialNumber = false;

-    m_bInX509Certificate = false;

-    m_bInGpgCertificate = false;

-    m_bInGpgKeyID = false;

-    m_bInGpgOwner = false;

-    m_bInSignatureValue = false;

-    m_bInDigestValue = false;

-    m_bInDate = false;

-    m_bInDescription = false;

+    private:

+        OUString m_Value;

-    if (m_xNextHandler.is())

-    {

-        m_xNextHandler->startDocument();

-    }

-}

+    public:

+        LoPGPOwnerContext(XSecParser & rParser,

+                std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap)

+            : XSecParser::Context(rParser, std::move(pOldNamespaceMap))

+        {

+        }

-void SAL_CALL XSecParser::endDocument(  )

+        virtual void EndElement() override

+        {

+            m_rParser.m_pXSecController->setGpgOwner(m_Value);

+        }

+

+        virtual void Characters(OUString const& rChars) override

+        {

+            m_Value += rChars;

+        }

+};

+

+class XSecParser::DsPGPKeyPacketContext

+    : public XSecParser::Context

 {

-    if (m_xNextHandler.is())

-    {

-        m_xNextHandler->endDocument();

-    }

-}

+    private:

+        OUString m_Value;

+

+    public:

+        DsPGPKeyPacketContext(XSecParser & rParser,

+                std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap)

+            : XSecParser::Context(rParser, std::move(pOldNamespaceMap))

+        {

+        }

+

+        virtual void EndElement() override

+        {

+            m_rParser.m_pXSecController->setGpgCertificate(m_Value);

+        }

+

+        virtual void Characters(OUString const& rChars) override

+        {

+            m_Value += rChars;

+        }

+};

+

+class XSecParser::DsPGPKeyIDContext

+    : public XSecParser::Context

+{

+    private:

+        OUString m_Value;

+

+    public:

+        DsPGPKeyIDContext(XSecParser & rParser,

+                std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap)

+            : XSecParser::Context(rParser, std::move(pOldNamespaceMap))

+        {

+        }

+

+        virtual void EndElement() override

+        {

+            m_rParser.m_pXSecController->setGpgKeyID(m_Value);

+        }

+

+        virtual void Characters(OUString const& rChars) override

+        {

+            m_Value += rChars;

+        }

+};

+

+class XSecParser::DsPGPDataContext

+    : public XSecParser::Context

+{

+    public:

+        DsPGPDataContext(XSecParser & rParser,

+                std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap)

+            : XSecParser::Context(rParser, std::move(pOldNamespaceMap))

+        {

+        }

+

+        virtual void StartElement(

+            css::uno::Reference<css::xml::sax::XAttributeList> const& /*xAttrs*/) override

+        {

+            m_rParser.m_pXSecController->switchGpgSignature();

+        }

+

+        virtual std::unique_ptr<Context> CreateChildContext(

+            std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap,

+            sal_uInt16 const nNamespace, OUString const& rName) override

+        {

+            if (nNamespace == XML_NAMESPACE_DS && rName == "PGPKeyID")

+            {

+                return std::make_unique<DsPGPKeyIDContext>(m_rParser, std::move(pOldNamespaceMap));

+            }

+            if (nNamespace == XML_NAMESPACE_DS && rName == "PGPKeyPacket")

+            {

+                return std::make_unique<DsPGPKeyPacketContext>(m_rParser, std::move(pOldNamespaceMap));

+            }

+            if (nNamespace == XML_NAMESPACE_LO_EXT && rName == "PGPOwner")

+            {

+                return std::make_unique<LoPGPOwnerContext>(m_rParser, std::move(pOldNamespaceMap));

+            }

+            return XSecParser::Context::CreateChildContext(std::move(pOldNamespaceMap), nNamespace, rName);

+        }

+};

+

+class XSecParser::DsX509CertificateContext

+    : public XSecParser::Context

+{

+    private:

+        OUString m_Value;

+

+    public:

+        DsX509CertificateContext(XSecParser & rParser,

+                std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap)

+            : XSecParser::Context(rParser, std::move(pOldNamespaceMap))

+        {

+        }

+

+        virtual void EndElement() override

+        {

+            m_rParser.m_pXSecController->setX509Certificate(m_Value);

+        }

+

+        virtual void Characters(OUString const& rChars) override

+        {

+            m_Value += rChars;

+        }

+};

+

+class XSecParser::DsX509SerialNumberContext

+    : public XSecParser::Context

+{

+    private:

+        OUString m_Value;

+

+    public:

+        DsX509SerialNumberContext(XSecParser & rParser,

+                std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap)

+            : XSecParser::Context(rParser, std::move(pOldNamespaceMap))

+        {

+        }

+

+        virtual void EndElement() override

+        {

+            m_rParser.m_pXSecController->setX509SerialNumber(m_Value);

+        }

+

+        virtual void Characters(OUString const& rChars) override

+        {

+            m_Value += rChars;

+        }

+};

+

+class XSecParser::DsX509IssuerNameContext

+    : public XSecParser::Context

+{

+    private:

+        OUString m_Value;

+

+    public:

+        DsX509IssuerNameContext(XSecParser & rParser,

+                std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap)

+            : XSecParser::Context(rParser, std::move(pOldNamespaceMap))

+        {

+        }

+

+        virtual void EndElement() override

+        {

+            m_rParser.m_pXSecController->setX509IssuerName(m_Value);

+        }

+

+        virtual void Characters(OUString const& rChars) override

+        {

+            m_Value += rChars;

+        }

+};

+

+class XSecParser::DsX509IssuerSerialContext

+    : public XSecParser::Context

+{

+    public:

+        DsX509IssuerSerialContext(XSecParser & rParser,

+                std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap)

+            : XSecParser::Context(rParser, std::move(pOldNamespaceMap))

+        {

+        }

+

+        virtual std::unique_ptr<Context> CreateChildContext(

+            std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap,

+            sal_uInt16 const nNamespace, OUString const& rName) override

+        {

+            if (nNamespace == XML_NAMESPACE_DS && rName == "X509IssuerName")

+            {

+                return std::make_unique<DsX509IssuerNameContext>(m_rParser, std::move(pOldNamespaceMap));

+            }

+            if (nNamespace == XML_NAMESPACE_DS && rName == "X509SerialNumber")

+            {

+                return std::make_unique<DsX509SerialNumberContext>(m_rParser, std::move(pOldNamespaceMap));

+            }

+            // missing: ds:X509SKI, ds:X509SubjectName, ds:X509CRL

+            return XSecParser::Context::CreateChildContext(std::move(pOldNamespaceMap), nNamespace, rName);

+        }

+};

+

+class XSecParser::DsX509DataContext

+    : public XSecParser::Context

+{

+    public:

+        DsX509DataContext(XSecParser & rParser,

+                std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap)

+            : XSecParser::Context(rParser, std::move(pOldNamespaceMap))

+        {

+        }

+

+        virtual std::unique_ptr<Context> CreateChildContext(

+            std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap,

+            sal_uInt16 const nNamespace, OUString const& rName) override

+        {

+            if (nNamespace == XML_NAMESPACE_DS && rName == "X509IssuerSerial")

+            {

+                return std::make_unique<DsX509IssuerSerialContext>(m_rParser, std::move(pOldNamespaceMap));

+            }

+            if (nNamespace == XML_NAMESPACE_DS && rName == "X509Certificate")

+            {

+                return std::make_unique<DsX509CertificateContext>(m_rParser, std::move(pOldNamespaceMap));

+            }

+            // missing: ds:X509SKI, ds:X509SubjectName, ds:X509CRL

+            return XSecParser::Context::CreateChildContext(std::move(pOldNamespaceMap), nNamespace, rName);

+        }

+};

+

+class XSecParser::DsKeyInfoContext

+    : public XSecParser::Context

+{

+    public:

+        DsKeyInfoContext(XSecParser & rParser,

+                std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap)

+            : XSecParser::Context(rParser, std::move(pOldNamespaceMap))

+        {

+        }

+

+        virtual void StartElement(

+            css::uno::Reference<css::xml::sax::XAttributeList> const& xAttrs) override

+        {

+            m_rParser.HandleIdAttr(xAttrs);

+        }

+

+        virtual std::unique_ptr<Context> CreateChildContext(

+            std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap,

+            sal_uInt16 const nNamespace, OUString const& rName) override

+        {

+            if (nNamespace == XML_NAMESPACE_DS && rName == "X509Data")

+            {

+                return std::make_unique<DsX509DataContext>(m_rParser, std::move(pOldNamespaceMap));

+            }

+            if (nNamespace == XML_NAMESPACE_DS && rName == "PGPData")

+            {

+                return std::make_unique<DsPGPDataContext>(m_rParser, std::move(pOldNamespaceMap));

+            }

+            // missing: ds:KeyName, ds:KeyValue, ds:RetrievalMethod, ds:SPKIData, ds:MgmtData

+            // (old code would read ds:Transform inside ds:RetrievalMethod but

+            // presumably that was a bug)

+            return XSecParser::Context::CreateChildContext(std::move(pOldNamespaceMap), nNamespace, rName);

+        }

+

+};

+

+class XSecParser::DsSignatureValueContext

+    : public XSecParser::Context

+{

+    private:

+        OUString m_Value;

+

+    public:

+        DsSignatureValueContext(XSecParser & rParser,

+                std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap)

+            : XSecParser::Context(rParser, std::move(pOldNamespaceMap))

+        {

+        }

+

+        virtual void StartElement(

+            css::uno::Reference<css::xml::sax::XAttributeList> const& xAttrs) override

+        {

+            m_rParser.HandleIdAttr(xAttrs);

+        }

+

+        virtual void EndElement() override

+        {

+            m_rParser.m_pXSecController->setSignatureValue(m_Value);

+        }

+

+        virtual void Characters(OUString const& rChars) override

+        {

+            m_Value += rChars;

+        }

+};

+

+class XSecParser::DsDigestValueContext

+    : public XSecParser::Context

+{

+    private:

+        OUString & m_rValue;

+

+    public:

+        DsDigestValueContext(XSecParser & rParser,

+                std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap,

+                OUString & rValue)

+            : XSecParser::Context(rParser, std::move(pOldNamespaceMap))

+            , m_rValue(rValue)

+        {

+        }

+

+        virtual void StartElement(

+            css::uno::Reference<css::xml::sax::XAttributeList> const& /*xAttrs*/) override

+        {

+            m_rValue.clear();

+        }

+

+        virtual void Characters(OUString const& rChars) override

+        {

+            m_rValue += rChars;

+        }

+};

+

+class XSecParser::DsDigestMethodContext

+    : public XSecParser::Context

+{

+    private:

+        sal_Int32 & m_rReferenceDigestID;

+

+    public:

+        DsDigestMethodContext(XSecParser & rParser,

+                std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap,

+                sal_Int32 & rReferenceDigestID)