xmlsecurity/source/helper/xsecparser.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 #include "xsecparser.hxx"
  22 #include <xsecctl.hxx>
  23 #include <xmlsignaturehelper.hxx>
  24
  25 #include <xmloff/xmlnamespace.hxx>
  26 #include <xmloff/xmlimp.hxx>
  27
  28 #include <com/sun/star/xml/sax/SAXException.hpp>
  29 #include <cppuhelper/exc_hlp.hxx>
  30 #include <sal/log.hxx>
  31
  32 class XSecParser::Context
  33 {
  34     protected:
  35         friend class XSecParser;
  36         XSecParser & m_rParser;
  37     private:
  38         std::unique_ptr<SvXMLNamespaceMap> m_pOldNamespaceMap;
  39
  40     public:
  41         Context(XSecParser & rParser,
  42                 std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap)
  43             : m_rParser(rParser)
  44             , m_pOldNamespaceMap(std::move(pOldNamespaceMap))
  45         {
  46         }
  47
  48         virtual ~Context() = default;
  49
  50         virtual void StartElement(
  51             css::uno::Reference<css::xml::sax::XAttributeList> const& /*xAttrs*/)
  52         {
  53         }
  54
  55         virtual void EndElement()
  56         {
  57         }
  58
  59         virtual std::unique_ptr<Context> CreateChildContext(
  60             std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap,
  61             sal_uInt16 const /*nNamespace*/, OUString const& /*rName*/);
  62
  63         virtual void Characters(OUString const& /*rChars*/)
  64         {
  65         }
  66 };
  67
  68 // it's possible that an unsupported element has an Id attribute and a
  69 // ds:Reference digesting it - probably this means XSecController needs to know
  70 // about it. (For known elements, the Id attribute is only processed according
  71 // to the schema.)
  72 class XSecParser::UnknownContext
  73     : public XSecParser::Context
  74 {
  75     public:
  76         UnknownContext(XSecParser & rParser,
  77                 std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap)
  78             : XSecParser::Context(rParser, std::move(pOldNamespaceMap))
  79         {
  80         }
  81
  82         virtual void StartElement(
  83             css::uno::Reference<css::xml::sax::XAttributeList> const& xAttrs) override
  84         {
  85             m_rParser.HandleIdAttr(xAttrs);
  86         }
  87 };
  88
  89 auto XSecParser::Context::CreateChildContext(
  90     std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap,
  91     sal_uInt16 const /*nNamespace*/, OUString const& /*rName*/)
  92 -> std::unique_ptr<Context>
  93 {
  94     // default: create new base context
  95     return std::make_unique<UnknownContext>(m_rParser, std::move(pOldNamespaceMap));
  96 }
  97
  98 /**
  99 note: anything in ds:Object should be trusted *only* if there is a ds:Reference
 100       to it so it is signed (exception: the xades:EncapsulatedX509Certificate).
 101       ds:SignedInfo precedes all ds:Object.
 102
 103       There may be multiple ds:Signature for purpose of counter-signatures
 104       but the way XAdES describes these, only the ds:SignatureValue element
 105       would be referenced, so requiring a ds:Reference for anything in
 106       ds:Object shouldn't cause issues.
 107  */
 108 class XSecParser::ReferencedContextImpl
 109     : public XSecParser::Context
 110 {
 111     protected:
 112         bool m_isReferenced;
 113
 114     public:
 115         ReferencedContextImpl(XSecParser & rParser,
 116                 std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap,
 117                 bool const isReferenced)
 118             : XSecParser::Context(rParser, std::move(pOldNamespaceMap))
 119             , m_isReferenced(isReferenced)
 120         {
 121         }
 122
 123         OUString CheckIdAttrReferenced(css::uno::Reference<css::xml::sax::XAttributeList> const& xAttrs)
 124         {
 125             OUString const id(m_rParser.HandleIdAttr(xAttrs));
 126             if (!id.isEmpty() && m_rParser.m_pXSecController->haveReferenceForId(id))
 127             {
 128                 m_isReferenced = true;
 129             }
 130             return id;
 131         }
 132 };
 133
 134 class XSecParser::LoPGPOwnerContext
 135     : public XSecParser::Context
 136 {
 137     private:
 138         OUString m_Value;
 139
 140     public:
 141         LoPGPOwnerContext(XSecParser & rParser,
 142                 std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap)
 143             : XSecParser::Context(rParser, std::move(pOldNamespaceMap))
 144         {
 145         }
 146
 147         virtual void EndElement() override
 148         {
 149             m_rParser.m_pXSecController->setGpgOwner(m_Value);
 150         }
 151
 152         virtual void Characters(OUString const& rChars) override
 153         {
 154             m_Value += rChars;
 155         }
 156 };
 157
 158 class XSecParser::DsPGPKeyPacketContext
 159     : public XSecParser::Context
 160 {
 161     private:
 162         OUString m_Value;
 163
 164     public:
 165         DsPGPKeyPacketContext(XSecParser & rParser,
 166                 std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap)
 167             : XSecParser::Context(rParser, std::move(pOldNamespaceMap))
 168         {
 169         }
 170
 171         virtual void EndElement() override
 172         {
 173             m_rParser.m_pXSecController->setGpgCertificate(m_Value);
 174         }
 175
 176         virtual void Characters(OUString const& rChars) override
 177         {
 178             m_Value += rChars;
 179         }
 180 };
 181
 182 class XSecParser::DsPGPKeyIDContext
 183     : public XSecParser::Context
 184 {
 185     private:
 186         OUString m_Value;
 187
 188     public:
 189         DsPGPKeyIDContext(XSecParser & rParser,
 190                 std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap)
 191             : XSecParser::Context(rParser, std::move(pOldNamespaceMap))
 192         {
 193         }
 194
 195         virtual void EndElement() override
 196         {
 197             m_rParser.m_pXSecController->setGpgKeyID(m_Value);
 198         }
 199
 200         virtual void Characters(OUString const& rChars) override
 201         {
 202             m_Value += rChars;
 203         }
 204 };
 205
 206 class XSecParser::DsPGPDataContext
 207     : public XSecParser::Context
 208 {
 209     public:
 210         DsPGPDataContext(XSecParser & rParser,
 211                 std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap)
 212             : XSecParser::Context(rParser, std::move(pOldNamespaceMap))
 213         {
 214         }
 215
 216         virtual void StartElement(
 217             css::uno::Reference<css::xml::sax::XAttributeList> const& /*xAttrs*/) override
 218         {
 219             m_rParser.m_pXSecController->switchGpgSignature();
 220         }
 221
 222         virtual std::unique_ptr<Context> CreateChildContext(
 223             std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap,
 224             sal_uInt16 const nNamespace, OUString const& rName) override
 225         {
 226             if (nNamespace == XML_NAMESPACE_DS && rName == "PGPKeyID")
 227             {
 228                 return std::make_unique<DsPGPKeyIDContext>(m_rParser, std::move(pOldNamespaceMap));
 229             }
 230             if (nNamespace == XML_NAMESPACE_DS && rName == "PGPKeyPacket")
 231             {
 232                 return std::make_unique<DsPGPKeyPacketContext>(m_rParser, std::move(pOldNamespaceMap));
 233             }
 234             if (nNamespace == XML_NAMESPACE_LO_EXT && rName == "PGPOwner")
 235             {
 236                 return std::make_unique<LoPGPOwnerContext>(m_rParser, std::move(pOldNamespaceMap));
 237             }
 238             return XSecParser::Context::CreateChildContext(std::move(pOldNamespaceMap), nNamespace, rName);
 239         }
 240 };
 241
 242 class XSecParser::DsX509CertificateContext
 243     : public XSecParser::Context
 244 {
 245     private:
 246         OUString & m_rValue;
 247
 248     public:
 249         DsX509CertificateContext(XSecParser & rParser,
 250                 std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap,
 251                 OUString & rValue)
 252             : XSecParser::Context(rParser, std::move(pOldNamespaceMap))
 253             , m_rValue(rValue)
 254         {
 255         }
 256
 257         virtual void Characters(OUString const& rChars) override
 258         {
 259             m_rValue += rChars;
 260         }
 261 };
 262
 263 class XSecParser::DsX509SerialNumberContext
 264     : public XSecParser::Context
 265 {
 266     private:
 267         OUString & m_rValue;
 268
 269     public:
 270         DsX509SerialNumberContext(XSecParser & rParser,
 271                 std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap,
 272                 OUString & rValue)
 273             : XSecParser::Context(rParser, std::move(pOldNamespaceMap))
 274             , m_rValue(rValue)
 275         {
 276         }
 277
 278         virtual void Characters(OUString const& rChars) override
 279         {
 280             m_rValue += rChars;
 281         }
 282 };
 283
 284 class XSecParser::DsX509IssuerNameContext
 285     : public XSecParser::Context
 286 {
 287     private:
 288         OUString & m_rValue;
 289
 290     public:
 291         DsX509IssuerNameContext(XSecParser & rParser,
 292                 std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap,
 293                 OUString & rValue)
 294             : XSecParser::Context(rParser, std::move(pOldNamespaceMap))
 295             , m_rValue(rValue)
 296         {
 297         }
 298
 299         virtual void Characters(OUString const& rChars) override
 300         {
 301             m_rValue += rChars;
 302         }
 303 };
 304
 305 class XSecParser::DsX509IssuerSerialContext
 306     : public XSecParser::Context
 307 {
 308     private:
 309         OUString & m_rX509IssuerName;
 310         OUString & m_rX509SerialNumber;
 311
 312     public:
 313         DsX509IssuerSerialContext(XSecParser & rParser,
 314                 std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap,
 315                 OUString & rIssuerName, OUString & rSerialNumber)
 316             : XSecParser::Context(rParser, std::move(pOldNamespaceMap))
 317             , m_rX509IssuerName(rIssuerName)
 318             , m_rX509SerialNumber(rSerialNumber)
 319         {
 320         }
 321
 322         virtual std::unique_ptr<Context> CreateChildContext(
 323             std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap,
 324             sal_uInt16 const nNamespace, OUString const& rName) override
 325         {
 326             if (nNamespace == XML_NAMESPACE_DS && rName == "X509IssuerName")
 327             {
 328                 return std::make_unique<DsX509IssuerNameContext>(m_rParser, std::move(pOldNamespaceMap), m_rX509IssuerName);
 329             }
 330             if (nNamespace == XML_NAMESPACE_DS && rName == "X509SerialNumber")
 331             {
 332                 return std::make_unique<DsX509SerialNumberContext>(m_rParser, std::move(pOldNamespaceMap), m_rX509SerialNumber);
 333             }
 334             // missing: ds:X509SKI, ds:X509SubjectName, ds:X509CRL
 335             return XSecParser::Context::CreateChildContext(std::move(pOldNamespaceMap), nNamespace, rName);
 336         }
 337 };
 338
 339 /// can't be sure what is supposed to happen here because the spec is clear as mud
 340 class XSecParser::DsX509DataContext
 341     : public XSecParser::Context
 342 {
 343     private:
 344         // sigh... "No ordering is implied by the above constraints."
 345         // so store the ball of mud in vectors and try to figure it out later.
 346         std::vector<std::pair<OUString, OUString>> m_X509IssuerSerials;
 347         std::vector<OUString> m_X509Certificates;
 348
 349     public:
 350         DsX509DataContext(XSecParser & rParser,
 351                 std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap)
 352             : XSecParser::Context(rParser, std::move(pOldNamespaceMap))
 353         {
 354         }
 355
 356         virtual void EndElement() override
 357         {
 358             m_rParser.m_pXSecController->setX509Data(m_X509IssuerSerials, m_X509Certificates);
 359         }
 360
 361         virtual std::unique_ptr<Context> CreateChildContext(
 362             std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap,
 363             sal_uInt16 const nNamespace, OUString const& rName) override
 364         {
 365             if (nNamespace == XML_NAMESPACE_DS && rName == "X509IssuerSerial")
 366             {
 367                 m_X509IssuerSerials.emplace_back();
 368                 return std::make_unique<DsX509IssuerSerialContext>(m_rParser, std::move(pOldNamespaceMap), m_X509IssuerSerials.back().first, m_X509IssuerSerials.back().second);
 369             }
 370             if (nNamespace == XML_NAMESPACE_DS && rName == "X509Certificate")
 371             {
 372                 m_X509Certificates.emplace_back();
 373                 return std::make_unique<DsX509CertificateContext>(m_rParser, std::move(pOldNamespaceMap), m_X509Certificates.back());
 374             }
 375             // missing: ds:X509SKI, ds:X509SubjectName, ds:X509CRL
 376             return XSecParser::Context::CreateChildContext(std::move(pOldNamespaceMap), nNamespace, rName);
 377         }
 378 };
 379
 380 class XSecParser::DsKeyInfoContext
 381     : public XSecParser::Context
 382 {
 383     public:
 384         DsKeyInfoContext(XSecParser & rParser,
 385                 std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap)
 386             : XSecParser::Context(rParser, std::move(pOldNamespaceMap))
 387         {
 388         }
 389
 390         virtual void StartElement(
 391             css::uno::Reference<css::xml::sax::XAttributeList> const& xAttrs) override
 392         {
 393             m_rParser.HandleIdAttr(xAttrs);
 394         }
 395
 396         virtual std::unique_ptr<Context> CreateChildContext(
 397             std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap,
 398             sal_uInt16 const nNamespace, OUString const& rName) override
 399         {
 400             if (nNamespace == XML_NAMESPACE_DS && rName == "X509Data")
 401             {
 402                 return std::make_unique<DsX509DataContext>(m_rParser, std::move(pOldNamespaceMap));
 403             }
 404             if (nNamespace == XML_NAMESPACE_DS && rName == "PGPData")
 405             {
 406                 return std::make_unique<DsPGPDataContext>(m_rParser, std::move(pOldNamespaceMap));
 407             }
 408             // missing: ds:KeyName, ds:KeyValue, ds:RetrievalMethod, ds:SPKIData, ds:MgmtData
 409             // (old code would read ds:Transform inside ds:RetrievalMethod but
 410             // presumably that was a bug)
 411             return XSecParser::Context::CreateChildContext(std::move(pOldNamespaceMap), nNamespace, rName);
 412         }
 413
 414 };
 415
 416 class XSecParser::DsSignatureValueContext
 417     : public XSecParser::Context
 418 {
 419     private:
 420         OUString m_Value;
 421
 422     public:
 423         DsSignatureValueContext(XSecParser & rParser,
 424                 std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap)
 425             : XSecParser::Context(rParser, std::move(pOldNamespaceMap))
 426         {
 427         }
 428
 429         virtual void StartElement(
 430             css::uno::Reference<css::xml::sax::XAttributeList> const& xAttrs) override
 431         {
 432             m_rParser.HandleIdAttr(xAttrs);
 433         }
 434
 435         virtual void EndElement() override
 436         {
 437             m_rParser.m_pXSecController->setSignatureValue(m_Value);
 438         }
 439
 440         virtual void Characters(OUString const& rChars) override
 441         {
 442             m_Value += rChars;
 443         }
 444 };
 445
 446 class XSecParser::DsDigestValueContext
 447     : public XSecParser::Context
 448 {
 449     private:
 450         OUString & m_rValue;
 451
 452     public:
 453         DsDigestValueContext(XSecParser & rParser,
 454                 std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap,
 455                 OUString & rValue)
 456             : XSecParser::Context(rParser, std::move(pOldNamespaceMap))
 457             , m_rValue(rValue)
 458         {
 459         }
 460
 461         virtual void StartElement(
 462             css::uno::Reference<css::xml::sax::XAttributeList> const& /*xAttrs*/) override
 463         {
 464             m_rValue.clear();
 465         }
 466
 467         virtual void Characters(OUString const& rChars) override
 468         {
 469             m_rValue += rChars;
 470         }
 471 };
 472
 473 class XSecParser::DsDigestMethodContext
 474     : public XSecParser::Context
 475 {
 476     private:
 477         sal_Int32 & m_rReferenceDigestID;
 478
 479     public:
 480         DsDigestMethodContext(XSecParser & rParser,
 481                 std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap,
 482                 sal_Int32 & rReferenceDigestID)
 483             : XSecParser::Context(rParser, std::move(pOldNamespaceMap))
 484             , m_rReferenceDigestID(rReferenceDigestID)
 485         {
 486         }
 487
 488         virtual void StartElement(
 489             css::uno::Reference<css::xml::sax::XAttributeList> const& xAttrs) override
 490         {
 491             OUString ouAlgorithm = xAttrs->getValueByName("Algorithm");
 492
 493             SAL_WARN_IF( ouAlgorithm.isEmpty(), "xmlsecurity.helper", "no Algorithm in Reference" );
 494             if (!ouAlgorithm.isEmpty())
 495             {
 496                 SAL_WARN_IF( ouAlgorithm != ALGO_XMLDSIGSHA1
 497                              && ouAlgorithm != ALGO_XMLDSIGSHA256
 498                              && ouAlgorithm != ALGO_XMLDSIGSHA512,
 499                              "xmlsecurity.helper", "Algorithm neither SHA1, SHA256 nor SHA512");
 500                 if (ouAlgorithm == ALGO_XMLDSIGSHA1)
 501                     m_rReferenceDigestID = css::xml::crypto::DigestID::SHA1;
 502                 else if (ouAlgorithm == ALGO_XMLDSIGSHA256)
 503                     m_rReferenceDigestID = css::xml::crypto::DigestID::SHA256;
 504                 else if (ouAlgorithm == ALGO_XMLDSIGSHA512)
 505                     m_rReferenceDigestID = css::xml::crypto::DigestID::SHA512;
 506                 else
 507                     m_rReferenceDigestID = 0;
 508             }
 509         }
 510 };
 511
 512 class XSecParser::DsTransformContext
 513     : public XSecParser::Context
 514 {
 515     private:
 516         bool & m_rIsC14N;
 517
 518     public:
 519         DsTransformContext(XSecParser & rParser,
 520                 std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap,
 521                 bool & rIsC14N)
 522             : XSecParser::Context(rParser, std::move(pOldNamespaceMap))
 523             , m_rIsC14N(rIsC14N)
 524         {
 525         }
 526
 527         virtual void StartElement(
 528             css::uno::Reference<css::xml::sax::XAttributeList> const& xAttrs) override
 529         {
 530             OUString ouAlgorithm = xAttrs->getValueByName("Algorithm");
 531
 532             if (ouAlgorithm == ALGO_C14N)
 533                 /*
 534                  * a xml stream
 535                  */
 536             {
 537                 m_rIsC14N = true;
 538             }
 539         }
 540 };
 541
 542 class XSecParser::DsTransformsContext
 543     : public XSecParser::Context
 544 {
 545     private:
 546         bool & m_rIsC14N;
 547
 548     public:
 549         DsTransformsContext(XSecParser & rParser,
 550                 std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap,
 551                 bool & rIsC14N)
 552             : XSecParser::Context(rParser, std::move(pOldNamespaceMap))
 553             , m_rIsC14N(rIsC14N)
 554         {
 555         }
 556
 557         virtual std::unique_ptr<Context> CreateChildContext(
 558             std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap,
 559             sal_uInt16 const nNamespace, OUString const& rName) override
 560         {
 561             if (nNamespace == XML_NAMESPACE_DS && rName == "Transform")
 562             {
 563                 return std::make_unique<DsTransformContext>(m_rParser, std::move(pOldNamespaceMap), m_rIsC14N);
 564             }
 565             return XSecParser::Context::CreateChildContext(std::move(pOldNamespaceMap), nNamespace, rName);
 566         }
 567 };
 568
 569 class XSecParser::DsReferenceContext
 570     : public XSecParser::Context
 571 {
 572     private:
 573         OUString m_URI;
 574         OUString m_Type;
 575         OUString m_DigestValue;
 576         bool m_IsC14N = false;
 577         // Relevant for ODF. The digest algorithm selected by the DigestMethod
 578         // element's Algorithm attribute. @see css::xml::crypto::DigestID.
 579         sal_Int32 m_nReferenceDigestID = css::xml::crypto::DigestID::SHA1;
 580
 581     public:
 582         DsReferenceContext(XSecParser & rParser,
 583                 std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap)
 584             : XSecParser::Context(rParser, std::move(pOldNamespaceMap))
 585         {
 586         }
 587
 588         virtual void StartElement(
 589             css::uno::Reference<css::xml::sax::XAttributeList> const& xAttrs) override
 590         {
 591             m_rParser.HandleIdAttr(xAttrs);
 592
 593             m_URI = xAttrs->getValueByName("URI");
 594             SAL_WARN_IF(m_URI.isEmpty(), "xmlsecurity.helper", "URI is empty");
 595             // Remember the type of this reference.
 596             m_Type = xAttrs->getValueByName("Type");
 597         }
 598
 599         virtual void EndElement() override
 600         {
 601             if (m_URI.startsWith("#"))
 602             {
 603                 /*
 604                 * remove the first character '#' from the attribute value
 605                 */
 606                 m_rParser.m_pXSecController->addReference(m_URI.copy(1), m_nReferenceDigestID, m_Type);
 607             }
 608             else
 609             {
 610                 if (m_IsC14N) // this is determined by nested ds:Transform
 611                 {
 612                     m_rParser.m_pXSecController->addStreamReference(m_URI, false, m_nReferenceDigestID);
 613                 }
 614                 else
 615             /*
 616             * it must be an octet stream
 617             */
 618                 {
 619                     m_rParser.m_pXSecController->addStreamReference(m_URI, true, m_nReferenceDigestID);
 620                 }
 621             }
 622
 623             m_rParser.m_pXSecController->setDigestValue(m_nReferenceDigestID, m_DigestValue);
 624         }
 625
 626         virtual std::unique_ptr<Context> CreateChildContext(
 627             std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap,
 628             sal_uInt16 const nNamespace, OUString const& rName) override
 629         {
 630             if (nNamespace == XML_NAMESPACE_DS && rName == "Transforms")
 631             {
 632                 return std::make_unique<DsTransformsContext>(m_rParser, std::move(pOldNamespaceMap), m_IsC14N);
 633             }
 634             if (nNamespace == XML_NAMESPACE_DS && rName == "DigestMethod")
 635             {
 636                 return std::make_unique<DsDigestMethodContext>(m_rParser, std::move(pOldNamespaceMap), m_nReferenceDigestID);
 637             }
 638             if (nNamespace == XML_NAMESPACE_DS && rName == "DigestValue")
 639             {
 640                 return std::make_unique<DsDigestValueContext>(m_rParser, std::move(pOldNamespaceMap), m_DigestValue);
 641             }
 642             return XSecParser::Context::CreateChildContext(std::move(pOldNamespaceMap), nNamespace, rName);
 643         }
 644 };
 645
 646 class XSecParser::DsSignatureMethodContext
 647     : public XSecParser::Context
 648 {
 649     public:
 650         DsSignatureMethodContext(XSecParser & rParser,
 651                 std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap)
 652             : XSecParser::Context(rParser, std::move(pOldNamespaceMap))
 653         {
 654         }
 655
 656         virtual void StartElement(
 657             css::uno::Reference<css::xml::sax::XAttributeList> const& xAttrs) override
 658         {
 659             OUString ouAlgorithm = xAttrs->getValueByName("Algorithm");
 660             if (ouAlgorithm == ALGO_ECDSASHA1 || ouAlgorithm == ALGO_ECDSASHA256
 661                 || ouAlgorithm == ALGO_ECDSASHA512)
 662             {
 663                 m_rParser.m_pXSecController->setSignatureMethod(svl::crypto::SignatureMethodAlgorithm::ECDSA);
 664             }
 665         }
 666 };
 667
 668 class XSecParser::DsSignedInfoContext
 669     : public XSecParser::Context
 670 {
 671     public:
 672         DsSignedInfoContext(XSecParser & rParser,
 673                 std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap)
 674             : XSecParser::Context(rParser, std::move(pOldNamespaceMap))
 675         {
 676         }
 677
 678         virtual void StartElement(
 679             css::uno::Reference<css::xml::sax::XAttributeList> const& xAttrs) override
 680         {
 681             m_rParser.HandleIdAttr(xAttrs);
 682         }
 683
 684         virtual void EndElement() override
 685         {
 686             m_rParser.m_pXSecController->setReferenceCount();
 687         }
 688
 689         virtual std::unique_ptr<Context> CreateChildContext(
 690             std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap,
 691             sal_uInt16 const nNamespace, OUString const& rName) override
 692         {
 693             if (nNamespace == XML_NAMESPACE_DS && rName == "SignatureMethod")
 694             {
 695                 return std::make_unique<DsSignatureMethodContext>(m_rParser, std::move(pOldNamespaceMap));
 696             }
 697             if (nNamespace == XML_NAMESPACE_DS && rName == "Reference")
 698             {
 699                 return std::make_unique<DsReferenceContext>(m_rParser, std::move(pOldNamespaceMap));
 700             }
 701             // missing: ds:CanonicalizationMethod
 702             return XSecParser::Context::CreateChildContext(std::move(pOldNamespaceMap), nNamespace, rName);
 703         }
 704 };
 705
 706 class XSecParser::XadesEncapsulatedX509CertificateContext
 707     : public XSecParser::Context
 708 {
 709     private:
 710         OUString m_Value;
 711
 712     public:
 713         XadesEncapsulatedX509CertificateContext(XSecParser & rParser,
 714                 std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap)
 715             : XSecParser::Context(rParser, std::move(pOldNamespaceMap))
 716         {
 717         }
 718
 719         virtual void StartElement(
 720             css::uno::Reference<css::xml::sax::XAttributeList> const& xAttrs) override
 721         {
 722             m_rParser.HandleIdAttr(xAttrs);
 723         }
 724
 725         virtual void EndElement() override
 726         {
 727             m_rParser.m_pXSecController->addEncapsulatedX509Certificate(m_Value);
 728         }
 729
 730         virtual void Characters(OUString const& rChars) override
 731         {
 732             m_Value += rChars;
 733         }
 734 };
 735
 736 class XSecParser::XadesCertificateValuesContext
 737     : public XSecParser::Context
 738 {
 739     public:
 740         XadesCertificateValuesContext(XSecParser & rParser,
 741                 std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap)
 742             : XSecParser::Context(rParser, std::move(pOldNamespaceMap))
 743         {
 744         }
 745
 746         virtual void StartElement(
 747             css::uno::Reference<css::xml::sax::XAttributeList> const& xAttrs) override
 748         {
 749             m_rParser.HandleIdAttr(xAttrs);
 750         }
 751
 752         virtual std::unique_ptr<Context> CreateChildContext(
 753             std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap,
 754             sal_uInt16 const nNamespace, OUString const& rName) override
 755         {
 756             if (nNamespace == XML_NAMESPACE_XADES132 && rName == "EncapsulatedX509Certificate")
 757             {
 758                 return std::make_unique<XadesEncapsulatedX509CertificateContext>(m_rParser, std::move(pOldNamespaceMap));
 759             }
 760             // missing: xades:OtherCertificate
 761             return XSecParser::Context::CreateChildContext(std::move(pOldNamespaceMap), nNamespace, rName);
 762         }
 763 };
 764
 765 class XSecParser::XadesUnsignedSignaturePropertiesContext
 766     : public XSecParser::Context
 767 {
 768     public:
 769         XadesUnsignedSignaturePropertiesContext(XSecParser & rParser,
 770                 std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap)
 771             : XSecParser::Context(rParser, std::move(pOldNamespaceMap))
 772         {
 773         }
 774
 775         virtual void StartElement(
 776             css::uno::Reference<css::xml::sax::XAttributeList> const& xAttrs) override
 777         {
 778             m_rParser.HandleIdAttr(xAttrs);
 779         }
 780
 781         virtual std::unique_ptr<Context> CreateChildContext(
 782             std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap,
 783             sal_uInt16 const nNamespace, OUString const& rName) override
 784         {
 785             if (nNamespace == XML_NAMESPACE_XADES132 && rName == "CertificateValues")
 786             {
 787                 return std::make_unique<XadesCertificateValuesContext>(m_rParser, std::move(pOldNamespaceMap));
 788             }
 789             // missing:
 790             // xades:CounterSignature
 791             //  ^ old code would read a ds:Signature inside it?
 792             // xades:SignatureTimeStamp
 793             // xades:CompleteCertificateRefs
 794             // xades:CompleteRevocationRefs
 795             // xades:AttributeCertificateRefs
 796             // xades:AttributeRevocationRefs
 797             // xades:SigAndRefsTimeStamp
 798             // xades:RefsOnlyTimeStamp
 799             // xades:RevocationValues
 800             // xades:AttrAuthoritiesCertValues
 801             //  ^ old code: was equivalent to CertificateValues ???
 802             // xades:AttributeRevocationValues
 803             // xades:ArchiveTimeStamp
 804             return XSecParser::Context::CreateChildContext(std::move(pOldNamespaceMap), nNamespace, rName);
 805         }
 806 };
 807
 808 class XSecParser::XadesUnsignedPropertiesContext
 809     : public XSecParser::Context
 810 {
 811     public:
 812         XadesUnsignedPropertiesContext(XSecParser & rParser,
 813                 std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap)
 814             : XSecParser::Context(rParser, std::move(pOldNamespaceMap))
 815         {
 816         }
 817
 818         virtual void StartElement(
 819             css::uno::Reference<css::xml::sax::XAttributeList> const& xAttrs) override
 820         {
 821             m_rParser.HandleIdAttr(xAttrs);
 822         }
 823
 824         virtual std::unique_ptr<Context> CreateChildContext(
 825             std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap,
 826             sal_uInt16 const nNamespace, OUString const& rName) override
 827         {
 828             if (nNamespace == XML_NAMESPACE_XADES132 && rName == "UnsignedSignatureProperties")
 829             {
 830                 return std::make_unique<XadesUnsignedSignaturePropertiesContext>(m_rParser, std::move(pOldNamespaceMap));
 831             }
 832             // missing: xades:UnsignedDataObjectProperties
 833             return XSecParser::Context::CreateChildContext(std::move(pOldNamespaceMap), nNamespace, rName);
 834         }
 835 };
 836
 837 class XSecParser::LoSignatureLineIdContext
 838     : public XSecParser::ReferencedContextImpl
 839 {
 840     private:
 841         OUString m_Value;
 842
 843     public:
 844         LoSignatureLineIdContext(XSecParser & rParser,
 845                 std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap,
 846                 bool const isReferenced)
 847             : ReferencedContextImpl(rParser, std::move(pOldNamespaceMap), isReferenced)
 848         {
 849         }
 850
 851         virtual void EndElement() override
 852         {
 853             if (m_isReferenced)
 854             {
 855                 m_rParser.m_pXSecController->setSignatureLineId(m_Value);
 856             }
 857             else
 858             {
 859                 SAL_INFO("xmlsecurity.helper", "ignoring unsigned SignatureLineId");
 860             }
 861         }
 862
 863         virtual void Characters(OUString const& rChars) override
 864         {
 865             m_Value += rChars;
 866         }
 867 };
 868
 869 class XSecParser::LoSignatureLineValidImageContext
 870     : public XSecParser::ReferencedContextImpl
 871 {
 872     private:
 873         OUString m_Value;
 874
 875     public:
 876         LoSignatureLineValidImageContext(XSecParser & rParser,
 877                 std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap,
 878                 bool const isReferenced)
 879             : ReferencedContextImpl(rParser, std::move(pOldNamespaceMap), isReferenced)
 880         {
 881         }
 882
 883         virtual void EndElement() override
 884         {
 885             if (m_isReferenced)
 886             {
 887                 m_rParser.m_pXSecController->setValidSignatureImage(m_Value);
 888             }
 889             else
 890             {
 891                 SAL_INFO("xmlsecurity.helper", "ignoring unsigned SignatureLineValidImage");
 892             }
 893         }
 894
 895         virtual void Characters(OUString const& rChars) override
 896         {
 897             m_Value += rChars;
 898         }
 899 };
 900
 901 class XSecParser::LoSignatureLineInvalidImageContext
 902     : public XSecParser::ReferencedContextImpl
 903 {
 904     private:
 905         OUString m_Value;
 906
 907     public:
 908         LoSignatureLineInvalidImageContext(XSecParser & rParser,
 909                 std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap,
 910                 bool const isReferenced)
 911             : ReferencedContextImpl(rParser, std::move(pOldNamespaceMap), isReferenced)
 912         {
 913         }
 914
 915         virtual void EndElement() override
 916         {
 917             if (m_isReferenced)
 918             {
 919                 m_rParser.m_pXSecController->setInvalidSignatureImage(m_Value);
 920             }
 921             else
 922             {
 923                 SAL_INFO("xmlsecurity.helper", "ignoring unsigned SignatureLineInvalidImage");
 924             }
 925         }
 926
 927         virtual void Characters(OUString const& rChars) override
 928         {
 929             m_Value += rChars;
 930         }
 931 };
 932
 933 class XSecParser::LoSignatureLineContext
 934     : public XSecParser::ReferencedContextImpl
 935 {
 936     public:
 937         LoSignatureLineContext(XSecParser & rParser,
 938                 std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap,
 939                 bool const isReferenced)
 940             : ReferencedContextImpl(rParser, std::move(pOldNamespaceMap), isReferenced)
 941         {
 942         }
 943
 944         virtual std::unique_ptr<Context> CreateChildContext(
 945             std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap,
 946             sal_uInt16 const nNamespace, OUString const& rName) override
 947         {
 948             if (nNamespace == XML_NAMESPACE_LO_EXT && rName == "SignatureLineId")
 949             {
 950                 return std::make_unique<LoSignatureLineIdContext>(m_rParser, std::move(pOldNamespaceMap), m_isReferenced);
 951             }
 952             if (nNamespace == XML_NAMESPACE_LO_EXT && rName == "SignatureLineValidImage")
 953             {
 954                 return std::make_unique<LoSignatureLineValidImageContext>(m_rParser, std::move(pOldNamespaceMap), m_isReferenced);
 955             }
 956             if (nNamespace == XML_NAMESPACE_LO_EXT && rName == "SignatureLineInvalidImage")
 957             {
 958                 return std::make_unique<LoSignatureLineInvalidImageContext>(m_rParser, std::move(pOldNamespaceMap), m_isReferenced);
 959             }
 960             return XSecParser::Context::CreateChildContext(std::move(pOldNamespaceMap), nNamespace, rName);
 961         }
 962 };
 963
 964 class XSecParser::XadesCertDigestContext
 965     : public XSecParser::Context
 966 {
 967     private:
 968         OUString & m_rDigestValue;
 969         sal_Int32 & m_rReferenceDigestID;
 970
 971     public:
 972         XadesCertDigestContext(XSecParser & rParser,
 973                 std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap,
 974                 OUString & rDigestValue, sal_Int32 & rReferenceDigestID)
 975             : XSecParser::Context(rParser, std::move(pOldNamespaceMap))
 976             , m_rDigestValue(rDigestValue)
 977             , m_rReferenceDigestID(rReferenceDigestID)
 978         {
 979         }
 980
 981         virtual std::unique_ptr<Context> CreateChildContext(
 982             std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap,
 983             sal_uInt16 const nNamespace, OUString const& rName) override
 984         {
 985             if (nNamespace == XML_NAMESPACE_DS && rName == "DigestMethod")
 986             {
 987                 return std::make_unique<DsDigestMethodContext>(m_rParser, std::move(pOldNamespaceMap), m_rReferenceDigestID);
 988             }
 989             if (nNamespace == XML_NAMESPACE_DS && rName == "DigestValue")
 990             {
 991                 return std::make_unique<DsDigestValueContext>(m_rParser, std::move(pOldNamespaceMap), m_rDigestValue);
 992             }
 993             return XSecParser::Context::CreateChildContext(std::move(pOldNamespaceMap), nNamespace, rName);
 994         }
 995 };
 996
 997 class XSecParser::XadesCertContext
 998     : public XSecParser::ReferencedContextImpl
 999 {
1000     private:
1001         sal_Int32 m_nReferenceDigestID = css::xml::crypto::DigestID::SHA1;
1002         OUString m_CertDigest;
1003         OUString m_X509IssuerName;
1004         OUString m_X509SerialNumber;
1005
1006     public:
1007         XadesCertContext(XSecParser & rParser,
1008                 std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap,
1009                 bool const isReferenced)
1010             : ReferencedContextImpl(rParser, std::move(pOldNamespaceMap), isReferenced)
1011         {
1012         }
1013
1014         virtual void EndElement() override
1015         {
1016             if (m_isReferenced)
1017             {
1018                 m_rParser.m_pXSecController->setX509CertDigest(m_CertDigest, m_nReferenceDigestID, m_X509IssuerName, m_X509SerialNumber);
1019             }
1020             else
1021             {
1022                 SAL_INFO("xmlsecurity.helper", "ignoring unsigned xades:Cert");
1023             }
1024         }
1025
1026         virtual std::unique_ptr<Context> CreateChildContext(
1027             std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap,
1028             sal_uInt16 const nNamespace, OUString const& rName) override
1029         {
1030             if (nNamespace == XML_NAMESPACE_XADES132 && rName == "CertDigest")
1031             {
1032                 return std::make_unique<XadesCertDigestContext>(m_rParser, std::move(pOldNamespaceMap), m_CertDigest, m_nReferenceDigestID);
1033             }
1034             if (nNamespace == XML_NAMESPACE_XADES132 && rName == "IssuerSerial")
1035             {
1036                 return std::make_unique<DsX509IssuerSerialContext>(m_rParser, std::move(pOldNamespaceMap), m_X509IssuerName, m_X509SerialNumber);
1037             }
1038             return XSecParser::Context::CreateChildContext(std::move(pOldNamespaceMap), nNamespace, rName);
1039         }
1040 };
1041
1042 class XSecParser::XadesSigningCertificateContext
1043     : public XSecParser::ReferencedContextImpl
1044 {
1045     public:
1046         XadesSigningCertificateContext(XSecParser & rParser,
1047                 std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap,
1048                 bool const isReferenced)
1049             : ReferencedContextImpl(rParser, std::move(pOldNamespaceMap), isReferenced)
1050         {
1051         }
1052
1053         virtual std::unique_ptr<Context> CreateChildContext(
1054             std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap,
1055             sal_uInt16 const nNamespace, OUString const& rName) override
1056         {
1057             if (nNamespace == XML_NAMESPACE_XADES132 && rName == "Cert")
1058             {
1059                 return std::make_unique<XadesCertContext>(m_rParser, std::move(pOldNamespaceMap), m_isReferenced);
1060             }
1061             return XSecParser::Context::CreateChildContext(std::move(pOldNamespaceMap), nNamespace, rName);
1062         }
1063 };
1064
1065 class XSecParser::XadesSigningTimeContext
1066     : public XSecParser::ReferencedContextImpl
1067 {
1068     private:
1069         OUString m_Value;
1070
1071     public:
1072         XadesSigningTimeContext(XSecParser & rParser,
1073                 std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap,
1074                 bool const isReferenced)
1075             : ReferencedContextImpl(rParser, std::move(pOldNamespaceMap), isReferenced)
1076         {
1077         }
1078
1079         virtual void EndElement() override
1080         {
1081             if (m_isReferenced)
1082             {
1083                 m_rParser.m_pXSecController->setDate("", m_Value);
1084             }
1085             else
1086             {
1087                 SAL_INFO("xmlsecurity.helper", "ignoring unsigned SigningTime");
1088             }
1089         }
1090
1091         virtual void Characters(OUString const& rChars) override
1092         {
1093             m_Value += rChars;
1094         }
1095 };
1096
1097 class XSecParser::XadesSignedSignaturePropertiesContext
1098     : public XSecParser::ReferencedContextImpl
1099 {
1100     public:
1101         XadesSignedSignaturePropertiesContext(XSecParser & rParser,
1102                 std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap,
1103                 bool const isReferenced)
1104             : ReferencedContextImpl(rParser, std::move(pOldNamespaceMap), isReferenced)
1105         {
1106         }
1107
1108         virtual void StartElement(
1109             css::uno::Reference<css::xml::sax::XAttributeList> const& xAttrs) override
1110         {
1111             CheckIdAttrReferenced(xAttrs);
1112         }
1113
1114         virtual std::unique_ptr<Context> CreateChildContext(
1115             std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap,
1116             sal_uInt16 const nNamespace, OUString const& rName) override
1117         {
1118             if (nNamespace == XML_NAMESPACE_XADES132 && rName == "SigningTime")
1119             {
1120                 return std::make_unique<XadesSigningTimeContext>(m_rParser, std::move(pOldNamespaceMap), m_isReferenced);
1121             }
1122             if (nNamespace == XML_NAMESPACE_XADES132 && rName == "SigningCertificate")
1123             {
1124                 return std::make_unique<XadesSigningCertificateContext>(m_rParser, std::move(pOldNamespaceMap), m_isReferenced);
1125             }
1126             if (nNamespace == XML_NAMESPACE_LO_EXT && rName == "SignatureLine")
1127             {
1128                 return std::make_unique<LoSignatureLineContext>(m_rParser, std::move(pOldNamespaceMap), m_isReferenced);
1129             }
1130             // missing: xades:SignaturePolicyIdentifier, xades:SignatureProductionPlace, xades:SignerRole
1131             return XSecParser::Context::CreateChildContext(std::move(pOldNamespaceMap), nNamespace, rName);
1132         }
1133 };
1134
1135 class XSecParser::XadesSignedPropertiesContext
1136     : public XSecParser::ReferencedContextImpl
1137 {
1138     public:
1139         XadesSignedPropertiesContext(XSecParser & rParser,
1140                 std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap,
1141                 bool const isReferenced)
1142             : ReferencedContextImpl(rParser, std::move(pOldNamespaceMap), isReferenced)
1143         {
1144         }
1145
1146         virtual void StartElement(
1147             css::uno::Reference<css::xml::sax::XAttributeList> const& xAttrs) override
1148         {
1149             CheckIdAttrReferenced(xAttrs);
1150         }
1151
1152         virtual std::unique_ptr<Context> CreateChildContext(
1153             std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap,
1154             sal_uInt16 const nNamespace, OUString const& rName) override
1155         {
1156             if (nNamespace == XML_NAMESPACE_XADES132 && rName == "SignedSignatureProperties")
1157             {
1158                 return std::make_unique<XadesSignedSignaturePropertiesContext>(m_rParser, std::move(pOldNamespaceMap), m_isReferenced);
1159             }
1160             // missing: xades:SignedDataObjectProperties
1161             return XSecParser::Context::CreateChildContext(std::move(pOldNamespaceMap), nNamespace, rName);
1162         }
1163 };
1164
1165 class XSecParser::XadesQualifyingPropertiesContext
1166     : public XSecParser::ReferencedContextImpl
1167 {
1168     public:
1169         XadesQualifyingPropertiesContext(XSecParser & rParser,
1170                 std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap,
1171                 bool const isReferenced)
1172             : ReferencedContextImpl(rParser, std::move(pOldNamespaceMap), isReferenced)
1173         {
1174         }
1175
1176         virtual void StartElement(
1177             css::uno::Reference<css::xml::sax::XAttributeList> const& xAttrs) override
1178         {
1179             CheckIdAttrReferenced(xAttrs);
1180         }
1181
1182         virtual std::unique_ptr<Context> CreateChildContext(
1183             std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap,
1184             sal_uInt16 const nNamespace, OUString const& rName) override
1185         {
1186             if (nNamespace == XML_NAMESPACE_XADES132 && rName == "SignedProperties")
1187             {
1188                 return std::make_unique<XadesSignedPropertiesContext>(m_rParser, std::move(pOldNamespaceMap), m_isReferenced);
1189             }
1190             if (nNamespace == XML_NAMESPACE_XADES132 && rName == "UnsignedProperties")
1191             {
1192                 return std::make_unique<XadesUnsignedPropertiesContext>(m_rParser, std::move(pOldNamespaceMap));
1193             }
1194             return XSecParser::Context::CreateChildContext(std::move(pOldNamespaceMap), nNamespace, rName);
1195         }
1196 };
1197
1198 class XSecParser::DcDateContext
1199     : public XSecParser::Context
1200 {
1201     private:
1202         OUString & m_rValue;
1203
1204     public:
1205         DcDateContext(XSecParser & rParser,
1206                 std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap,
1207                 OUString & rValue)
1208             : XSecParser::Context(rParser, std::move(pOldNamespaceMap))
1209             , m_rValue(rValue)
1210         {
1211         }
1212
1213         virtual void Characters(OUString const& rChars) override
1214         {
1215             m_rValue += rChars;
1216         }
1217 };
1218
1219 class XSecParser::DcDescriptionContext
1220     : public XSecParser::Context
1221 {
1222     private:
1223         OUString & m_rValue;
1224
1225     public:
1226         DcDescriptionContext(XSecParser & rParser,
1227                 std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap,
1228                 OUString & rValue)
1229             : XSecParser::Context(rParser, std::move(pOldNamespaceMap))
1230             , m_rValue(rValue)
1231         {
1232         }
1233
1234         virtual void Characters(OUString const& rChars) override
1235         {
1236             m_rValue += rChars;
1237         }
1238 };
1239
1240 class XSecParser::DsSignaturePropertyContext
1241     : public XSecParser::ReferencedContextImpl
1242 {
1243     private:
1244         enum class SignatureProperty { Unknown, Date, Description };
1245         SignatureProperty m_Property = SignatureProperty::Unknown;
1246         OUString m_Id;
1247         OUString m_Value;
1248
1249     public:
1250         DsSignaturePropertyContext(XSecParser & rParser,
1251                 std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap,
1252                 bool const isReferenced)
1253             : ReferencedContextImpl(rParser, std::move(pOldNamespaceMap), isReferenced)
1254         {
1255         }
1256
1257         virtual void StartElement(
1258             css::uno::Reference<css::xml::sax::XAttributeList> const& xAttrs) override
1259         {
1260             m_Id = CheckIdAttrReferenced(xAttrs);
1261         }
1262
1263         virtual void EndElement() override
1264         {
1265             if (m_isReferenced)
1266             {
1267                 switch (m_Property)
1268                 {
1269                     case SignatureProperty::Unknown:
1270                         SAL_INFO("xmlsecurity.helper", "Unknown property in ds:Object ignored");
1271                         break;
1272                     case SignatureProperty::Date:
1273                         m_rParser.m_pXSecController->setDate(m_Id, m_Value);
1274                         break;
1275                     case SignatureProperty::Description:
1276                         m_rParser.m_pXSecController->setDescription(m_Id, m_Value);
1277                         break;
1278                 }
1279             }
1280             else
1281             {
1282                 SAL_INFO("xmlsecurity.helper", "ignoring unsigned SignatureProperty");
1283             }
1284         }
1285
1286         virtual std::unique_ptr<Context> CreateChildContext(
1287             std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap,
1288             sal_uInt16 const nNamespace, OUString const& rName) override
1289         {
1290             if (nNamespace == XML_NAMESPACE_DC && rName == "date")
1291             {
1292                 m_Property = SignatureProperty::Date;
1293                 return std::make_unique<DcDateContext>(m_rParser, std::move(pOldNamespaceMap), m_Value);
1294             }
1295             if (nNamespace == XML_NAMESPACE_DC && rName == "description")
1296             {
1297                 m_Property = SignatureProperty::Description;
1298                 return std::make_unique<DcDescriptionContext>(m_rParser, std::move(pOldNamespaceMap), m_Value);
1299             }
1300             return XSecParser::Context::CreateChildContext(std::move(pOldNamespaceMap), nNamespace, rName);
1301         }
1302 };
1303
1304 class XSecParser::DsSignaturePropertiesContext
1305     : public XSecParser::ReferencedContextImpl
1306 {
1307     public:
1308         DsSignaturePropertiesContext(XSecParser & rParser,
1309                 std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap,
1310                 bool const isReferenced)
1311             : ReferencedContextImpl(rParser, std::move(pOldNamespaceMap), isReferenced)
1312         {
1313         }
1314
1315         virtual void StartElement(
1316             css::uno::Reference<css::xml::sax::XAttributeList> const& xAttrs) override
1317         {
1318             CheckIdAttrReferenced(xAttrs);
1319         }
1320
1321         virtual std::unique_ptr<Context> CreateChildContext(
1322             std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap,
1323             sal_uInt16 const nNamespace, OUString const& rName) override
1324         {
1325             if (nNamespace == XML_NAMESPACE_DS && rName == "SignatureProperty")
1326             {
1327                 return std::make_unique<DsSignaturePropertyContext>(m_rParser, std::move(pOldNamespaceMap), m_isReferenced);
1328             }
1329             return XSecParser::Context::CreateChildContext(std::move(pOldNamespaceMap), nNamespace, rName);
1330         }
1331 };
1332
1333 class XSecParser::DsObjectContext
1334     : public XSecParser::ReferencedContextImpl
1335 {
1336     public:
1337         DsObjectContext(XSecParser & rParser,
1338                 std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap)
1339             // init with "false" here - the Signature element can't be referenced by its child
1340             : XSecParser::ReferencedContextImpl(rParser, std::move(pOldNamespaceMap), false)
1341         {
1342         }
1343
1344         virtual void StartElement(
1345             css::uno::Reference<css::xml::sax::XAttributeList> const& xAttrs) override
1346         {
1347             CheckIdAttrReferenced(xAttrs);
1348         }
1349
1350         virtual std::unique_ptr<Context> CreateChildContext(
1351             std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap,
1352             sal_uInt16 const nNamespace, OUString const& rName) override
1353         {
1354             if (nNamespace == XML_NAMESPACE_DS && rName == "SignatureProperties")
1355             {
1356                 return std::make_unique<DsSignaturePropertiesContext>(m_rParser, std::move(pOldNamespaceMap), m_isReferenced);
1357             }
1358             if (nNamespace == XML_NAMESPACE_XADES132 && rName == "QualifyingProperties")
1359             {
1360                 return std::make_unique<XadesQualifyingPropertiesContext>(m_rParser, std::move(pOldNamespaceMap), m_isReferenced);
1361             }
1362             // missing: ds:Manifest
1363             return XSecParser::Context::CreateChildContext(std::move(pOldNamespaceMap), nNamespace, rName);
1364         }
1365 };
1366
1367 class XSecParser::DsSignatureContext
1368     : public XSecParser::Context
1369 {
1370     public:
1371         DsSignatureContext(XSecParser & rParser,
1372                 std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap)
1373             : XSecParser::Context(rParser, std::move(pOldNamespaceMap))
1374         {
1375         }
1376
1377         virtual void StartElement(
1378             css::uno::Reference<css::xml::sax::XAttributeList> const& xAttrs) override
1379         {
1380             OUString const ouIdAttr(m_rParser.HandleIdAttr(xAttrs));
1381             m_rParser.m_rXMLSignatureHelper.StartVerifySignatureElement();
1382             m_rParser.m_pXSecController->addSignature();
1383             if (!ouIdAttr.isEmpty())
1384             {
1385                 m_rParser.m_pXSecController->setId( ouIdAttr );
1386             }
1387         }
1388
1389         virtual std::unique_ptr<Context> CreateChildContext(
1390             std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap,
1391             sal_uInt16 const nNamespace, OUString const& rName) override
1392         {
1393             if (nNamespace == XML_NAMESPACE_DS && rName == "SignedInfo")
1394             {
1395                 return std::make_unique<DsSignedInfoContext>(m_rParser, std::move(pOldNamespaceMap));
1396             }
1397             if (nNamespace == XML_NAMESPACE_DS && rName == "SignatureValue")
1398             {
1399                 return std::make_unique<DsSignatureValueContext>(m_rParser, std::move(pOldNamespaceMap));
1400             }
1401             if (nNamespace == XML_NAMESPACE_DS && rName == "KeyInfo")
1402             {
1403                 return std::make_unique<DsKeyInfoContext>(m_rParser, std::move(pOldNamespaceMap));
1404             }
1405             if (nNamespace == XML_NAMESPACE_DS && rName == "Object")
1406             {
1407                 return std::make_unique<DsObjectContext>(m_rParser, std::move(pOldNamespaceMap));
1408             }
1409             return XSecParser::Context::CreateChildContext(std::move(pOldNamespaceMap), nNamespace, rName);
1410         }
1411 };
1412
1413 class XSecParser::DsigSignaturesContext
1414     : public XSecParser::Context
1415 {
1416     public:
1417         DsigSignaturesContext(XSecParser & rParser,
1418                 std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap)
1419             : XSecParser::Context(rParser, std::move(pOldNamespaceMap))
1420         {
1421         }
1422
1423         virtual std::unique_ptr<Context> CreateChildContext(
1424             std::unique_ptr<SvXMLNamespaceMap> pOldNamespaceMap,
1425             sal_uInt16 const nNamespace, OUString const& rName) override
1426         {
1427             if (nNamespace == XML_NAMESPACE_DS && rName == "Signature")
1428             {
1429                 return std::make_unique<DsSignatureContext>(m_rParser, std::move(pOldNamespaceMap));
1430             }
1431             return XSecParser::Context::CreateChildContext(std::move(pOldNamespaceMap), nNamespace, rName);
1432         }
1433 };
1434
1435
1436 XSecParser::XSecParser(XMLSignatureHelper& rXMLSignatureHelper,
1437     XSecController* pXSecController)
1438     : m_pNamespaceMap(new SvXMLNamespaceMap)
1439     , m_pXSecController(pXSecController)
1440     , m_rXMLSignatureHelper(rXMLSignatureHelper)
1441 {
1442     using namespace xmloff::token;
1443     m_pNamespaceMap->Add( GetXMLToken(XML_XML), GetXMLToken(XML_N_XML), XML_NAMESPACE_XML );
1444     m_pNamespaceMap->Add( "_dsig_ooo", GetXMLToken(XML_N_DSIG_OOO), XML_NAMESPACE_DSIG_OOO );
1445     m_pNamespaceMap->Add( "_dsig", GetXMLToken(XML_N_DSIG), XML_NAMESPACE_DSIG );
1446     m_pNamespaceMap->Add( "_ds", GetXMLToken(XML_N_DS), XML_NAMESPACE_DS );
1447     m_pNamespaceMap->Add( "_xades132", GetXMLToken(XML_N_XADES132), XML_NAMESPACE_XADES132);
1448     m_pNamespaceMap->Add( "_xades141", GetXMLToken(XML_N_XADES141), XML_NAMESPACE_XADES141);
1449     m_pNamespaceMap->Add( "_dc", GetXMLToken(XML_N_DC), XML_NAMESPACE_DC );
1450     m_pNamespaceMap->Add( "_office_libo",
1451                          GetXMLToken(XML_N_LO_EXT), XML_NAMESPACE_LO_EXT);
1452 }
1453
1454 OUString XSecParser::HandleIdAttr(css::uno::Reference<css::xml::sax::XAttributeList> const& xAttrs)
1455 {
1456     OUString ouIdAttr = getIdAttr(xAttrs);
1457     if (!ouIdAttr.isEmpty())
1458     {
1459         m_pXSecController->collectToVerify( ouIdAttr );
1460     }
1461     return ouIdAttr;
1462 }
1463
1464 OUString XSecParser::getIdAttr(const css::uno::Reference< css::xml::sax::XAttributeList >& xAttribs )
1465 {
1466     OUString ouIdAttr = xAttribs->getValueByName("id");
1467
1468     if (ouIdAttr.isEmpty())
1469     {
1470         ouIdAttr = xAttribs->getValueByName("Id");
1471     }
1472
1473     return ouIdAttr;
1474 }
1475
1476 /*
1477  * XDocumentHandler
1478  */
1479 void SAL_CALL XSecParser::startDocument(  )
1480 {
1481     if (m_xNextHandler.is())
1482     {
1483         m_xNextHandler->startDocument();
1484     }
1485 }
1486
1487 void SAL_CALL XSecParser::endDocument(  )
1488 {
1489     if (m_xNextHandler.is())
1490     {
1491         m_xNextHandler->endDocument();
1492     }
1493 }
1494
1495 void SAL_CALL XSecParser::startElement(
1496     const OUString& rName,
1497     const css::uno::Reference< css::xml::sax::XAttributeList >& xAttribs )
1498 {
1499     assert(m_pNamespaceMap);
1500     std::unique_ptr<SvXMLNamespaceMap> pRewindMap(
1501         SvXMLImport::processNSAttributes(m_pNamespaceMap, nullptr, xAttribs));
1502
1503     OUString localName;
1504     sal_uInt16 const nPrefix(m_pNamespaceMap->GetKeyByAttrName(rName, &localName));
1505
1506     std::unique_ptr<Context> pContext;
1507
1508     if (m_ContextStack.empty())
1509     {
1510         if ((nPrefix == XML_NAMESPACE_DSIG || nPrefix == XML_NAMESPACE_DSIG_OOO)
1511             && localName == "document-signatures")
1512         {
1513             pContext.reset(new DsigSignaturesContext(*this, std::move(pRewindMap)));
1514         }
1515         else
1516         {
1517             throw css::xml::sax::SAXException(
1518                 "xmlsecurity: unexpected root element", nullptr,
1519                 css::uno::Any());
1520         }
1521     }
1522     else
1523     {
1524         pContext = m_ContextStack.top()->CreateChildContext(
1525                 std::move(pRewindMap), nPrefix, localName);
1526     }
1527
1528     m_ContextStack.push(std::move(pContext));
1529     assert(!pRewindMap);
1530
1531     try
1532     {
1533         m_ContextStack.top()->StartElement(xAttribs);
1534
1535         if (m_xNextHandler.is())
1536         {
1537             m_xNextHandler->startElement(rName, xAttribs);
1538         }
1539     }
1540     catch (css::uno::Exception& )
1541     {//getCaughtException MUST be the first line in the catch block
1542         css::uno::Any exc =  cppu::getCaughtException();
1543         throw css::xml::sax::SAXException(
1544             "xmlsecurity: Exception in XSecParser::startElement",
1545             nullptr, exc);
1546     }
1547     catch (...)
1548     {
1549         throw css::xml::sax::SAXException(
1550             "xmlsecurity: unexpected exception in XSecParser::startElement", nullptr,
1551             css::uno::Any());
1552     }
1553 }
1554
1555 void SAL_CALL XSecParser::endElement(const OUString& rName)
1556 {
1557     assert(!m_ContextStack.empty()); // this should be checked by sax parser?
1558
1559     try
1560     {
1561         m_ContextStack.top()->EndElement();
1562
1563         if (m_xNextHandler.is())
1564         {
1565             m_xNextHandler->endElement(rName);
1566         }
1567     }
1568     catch (css::uno::Exception& )
1569     {//getCaughtException MUST be the first line in the catch block
1570         css::uno::Any exc =  cppu::getCaughtException();
1571         throw css::xml::sax::SAXException(
1572             "xmlsecurity: Exception in XSecParser::endElement",
1573             nullptr, exc);
1574     }
1575     catch (...)
1576     {
1577         throw css::xml::sax::SAXException(
1578             "xmlsecurity: unexpected exception in XSecParser::endElement", nullptr,
1579             css::uno::Any());
1580     }
1581
1582     if (m_ContextStack.top()->m_pOldNamespaceMap)
1583     {
1584         m_pNamespaceMap = std::move(m_ContextStack.top()->m_pOldNamespaceMap);
1585     }
1586     m_ContextStack.pop();
1587 }
1588
1589 void SAL_CALL XSecParser::characters(const OUString& rChars)
1590 {
1591     assert(!m_ContextStack.empty()); // this should be checked by sax parser?
1592     m_ContextStack.top()->Characters(rChars);
1593
1594     if (m_xNextHandler.is())
1595     {
1596         m_xNextHandler->characters(rChars);
1597     }
1598 }
1599
1600 void SAL_CALL XSecParser::ignorableWhitespace( const OUString& aWhitespaces )
1601 {
1602     if (m_xNextHandler.is())
1603     {
1604         m_xNextHandler->ignorableWhitespace( aWhitespaces );
1605     }
1606 }
1607
1608 void SAL_CALL XSecParser::processingInstruction( const OUString& aTarget, const OUString& aData )
1609 {
1610     if (m_xNextHandler.is())
1611     {
1612         m_xNextHandler->processingInstruction(aTarget, aData);
1613     }
1614 }
1615
1616 void SAL_CALL XSecParser::setDocumentLocator( const css::uno::Reference< css::xml::sax::XLocator >& xLocator )
1617 {
1618     if (m_xNextHandler.is())
1619     {
1620         m_xNextHandler->setDocumentLocator( xLocator );
1621     }
1622 }
1623
1624 /*
1625  * XInitialization
1626  */
1627 void SAL_CALL XSecParser::initialize(
1628     const css::uno::Sequence< css::uno::Any >& aArguments )
1629 {
1630     aArguments[0] >>= m_xNextHandler;
1631 }
1632
1633 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */