xmlsecurity/source/helper/xsecverify.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   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 #include <config_gpgme.h>
  21
  22 #include <xsecctl.hxx>
  23 #include "xsecparser.hxx"
  24 #include "ooxmlsecparser.hxx"
  25 #include <biginteger.hxx>
  26 #include <framework/signatureverifierimpl.hxx>
  27 #include <framework/saxeventkeeperimpl.hxx>
  28 #include <gpg/xmlsignature_gpgimpl.hxx>
  29 #include <gpg/SEInitializer.hxx>
  30
  31 #include <com/sun/star/uno/Sequence.hxx>
  32 #include <com/sun/star/xml/crypto/sax/XKeyCollector.hpp>
  33 #include <com/sun/star/xml/crypto/sax/ElementMarkPriority.hpp>
  34 #include <com/sun/star/xml/crypto/sax/XReferenceCollector.hpp>
  35 #include <com/sun/star/xml/crypto/sax/XSignatureVerifyResultBroadcaster.hpp>
  36 #include <com/sun/star/xml/crypto/XSEInitializer.hpp>
  37 #include <com/sun/star/graphic/GraphicProvider.hpp>
  38 #include <com/sun/star/embed/StorageFormats.hpp>
  39 #include <sal/log.hxx>
  40 #include <unotools/datetime.hxx>
  41 #include <comphelper/base64.hxx>
  42 #include <comphelper/processfactory.hxx>
  43 #include <comphelper/propertyvalue.hxx>
  44 #include <comphelper/seqstream.hxx>
  45
  46 namespace com::sun::star::graphic { class XGraphic; }
  47
  48 using namespace css;
  49 using namespace css::uno;
  50 using namespace css::beans;
  51
  52 /* protected: for signature verify */
  53 css::uno::Reference< css::xml::crypto::sax::XReferenceResolvedListener > XSecController::prepareSignatureToRead(
  54     sal_Int32 nSecurityId)
  55 {
  56     if ( m_eStatusOfSecurityComponents != InitializationState::INITIALIZED )
  57     {
  58         return nullptr;
  59     }
  60
  61     sal_Int32 nIdOfSignatureElementCollector;
  62     css::uno::Reference< css::xml::crypto::sax::XReferenceResolvedListener > xReferenceResolvedListener;
  63
  64     nIdOfSignatureElementCollector =
  65         m_xSAXEventKeeper->addSecurityElementCollector( css::xml::crypto::sax::ElementMarkPriority_BEFOREMODIFY, false);
  66
  67     m_xSAXEventKeeper->setSecurityId(nIdOfSignatureElementCollector, nSecurityId);
  68
  69         /*
  70          * create a SignatureVerifier
  71          */
  72     xReferenceResolvedListener = new SignatureVerifierImpl;
  73
  74     css::uno::Reference<css::lang::XInitialization> xInitialization(xReferenceResolvedListener, css::uno::UNO_QUERY);
  75
  76     css::uno::Sequence<css::uno::Any> args
  77     {
  78         Any(OUString::number(nSecurityId)),
  79         Any(uno::Reference<xml::crypto::sax::XSecuritySAXEventKeeper>(m_xSAXEventKeeper)),
  80         Any(OUString::number(nIdOfSignatureElementCollector)),
  81         Any(m_xSecurityContext),
  82         Any(m_xXMLSignature)
  83     };
  84     xInitialization->initialize(args);
  85
  86     css::uno::Reference< css::xml::crypto::sax::XSignatureVerifyResultBroadcaster >
  87         signatureVerifyResultBroadcaster(xReferenceResolvedListener, css::uno::UNO_QUERY);
  88
  89     signatureVerifyResultBroadcaster->addSignatureVerifyResultListener( this );
  90
  91     m_xSAXEventKeeper->addReferenceResolvedListener(
  92         nIdOfSignatureElementCollector,
  93         xReferenceResolvedListener);
  94
  95     css::uno::Reference<css::xml::crypto::sax::XKeyCollector> keyCollector (xReferenceResolvedListener, css::uno::UNO_QUERY);
  96     keyCollector->setKeyId(0);
  97
  98     return xReferenceResolvedListener;
  99 }
 100
 101 void XSecController::addSignature()
 102 {
 103     css::uno::Reference< css::xml::crypto::sax::XReferenceResolvedListener > xReferenceResolvedListener;
 104     sal_Int32 nSignatureId = 0;
 105
 106
 107     if (m_bVerifyCurrentSignature)
 108     {
 109         chainOn();
 110         xReferenceResolvedListener = prepareSignatureToRead( m_nReservedSignatureId );
 111         m_bVerifyCurrentSignature = false;
 112         nSignatureId = m_nReservedSignatureId;
 113     }
 114
 115     InternalSignatureInformation isi( nSignatureId, xReferenceResolvedListener );
 116     m_vInternalSignatureInformations.push_back( isi );
 117 }
 118
 119 void XSecController::setSignatureMethod(svl::crypto::SignatureMethodAlgorithm eAlgorithmID)
 120 {
 121     if (m_vInternalSignatureInformations.empty())
 122         return;
 123
 124     m_vInternalSignatureInformations.back().signatureInfor.eAlgorithmID = eAlgorithmID;
 125 }
 126
 127 void XSecController::switchGpgSignature()
 128 {
 129 #if HAVE_FEATURE_GPGME
 130     // swap signature verifier for the Gpg one
 131     m_xXMLSignature.set(new XMLSignature_GpgImpl());
 132     if (m_vInternalSignatureInformations.empty())
 133         return;
 134
 135     SignatureVerifierImpl* pImpl=
 136         dynamic_cast<SignatureVerifierImpl*>(
 137             m_vInternalSignatureInformations.back().xReferenceResolvedListener.get());
 138     if (pImpl)
 139     {
 140         css::uno::Reference<css::xml::crypto::XSEInitializer> xGpgSEInitializer(
 141             new SEInitializerGpg());
 142         pImpl->updateSignature(new XMLSignature_GpgImpl(),
 143                                xGpgSEInitializer->createSecurityContext(OUString()));
 144     }
 145 #else
 146     (void) this;
 147 #endif
 148 }
 149
 150 bool XSecController::haveReferenceForId(std::u16string_view rId) const
 151 {
 152     if (m_vInternalSignatureInformations.empty())
 153     {
 154         SAL_INFO("xmlsecurity.helper","XSecController::haveReferenceForId: no signature");
 155         return false;
 156     }
 157     InternalSignatureInformation const& rIsi(m_vInternalSignatureInformations.back());
 158     for (SignatureReferenceInformation const& rSri : rIsi.signatureInfor.vSignatureReferenceInfors)
 159     {
 160         if (rSri.nType == SignatureReferenceType::SAMEDOCUMENT
 161             && rSri.ouURI == rId) // ouUri has # stripped
 162         {
 163             return true;
 164         }
 165     }
 166     return false;
 167 }
 168
 169 void XSecController::addReference( const OUString& ouUri, sal_Int32 nDigestID, const OUString& ouType )
 170 {
 171     if (m_vInternalSignatureInformations.empty())
 172     {
 173         SAL_INFO("xmlsecurity.helper","XSecController::addReference: no signature");
 174         return;
 175     }
 176     InternalSignatureInformation &isi = m_vInternalSignatureInformations.back();
 177     isi.addReference(SignatureReferenceType::SAMEDOCUMENT, nDigestID, ouUri, -1, ouType );
 178 }
 179
 180 void XSecController::addStreamReference(
 181     const OUString& ouUri,
 182     bool isBinary,
 183     sal_Int32 nDigestID )
 184 {
 185     SignatureReferenceType type = (isBinary?SignatureReferenceType::BINARYSTREAM:SignatureReferenceType::XMLSTREAM);
 186
 187     if (m_vInternalSignatureInformations.empty())
 188     {
 189         SAL_INFO("xmlsecurity.helper","XSecController::addStreamReference: no signature");
 190         return;
 191     }
 192     InternalSignatureInformation &isi = m_vInternalSignatureInformations.back();
 193
 194     if ( isi.xReferenceResolvedListener.is() )
 195     {
 196             /*
 197              * get the input stream
 198              */
 199         css::uno::Reference< css::io::XInputStream > xObjectInputStream
 200                 = getObjectInputStream( ouUri );
 201
 202         if ( xObjectInputStream.is() )
 203         {
 204             css::uno::Reference<css::xml::crypto::XUriBinding> xUriBinding
 205                 (isi.xReferenceResolvedListener, css::uno::UNO_QUERY);
 206             xUriBinding->setUriBinding(ouUri, xObjectInputStream);
 207         }
 208     }
 209
 210     isi.addReference(type, nDigestID, ouUri, -1, OUString());
 211 }
 212
 213 void XSecController::setReferenceCount() const
 214 {
 215     if (m_vInternalSignatureInformations.empty())
 216     {
 217         SAL_INFO("xmlsecurity.helper","XSecController::setReferenceCount: no signature");
 218         return;
 219     }
 220     const InternalSignatureInformation &isi =
 221         m_vInternalSignatureInformations.back();
 222
 223     if ( !isi.xReferenceResolvedListener.is() )
 224         return;
 225
 226     const SignatureReferenceInformations &refInfors = isi.signatureInfor.vSignatureReferenceInfors;
 227
 228     int refNum = refInfors.size();
 229     sal_Int32 referenceCount = 0;
 230
 231     for(int i=0 ; i<refNum; ++i)
 232     {
 233         if (refInfors[i].nType == SignatureReferenceType::SAMEDOCUMENT )
 234         /*
 235          * same-document reference
 236          */
 237         {
 238             referenceCount++;
 239         }
 240     }
 241
 242     css::uno::Reference<css::xml::crypto::sax::XReferenceCollector> xReferenceCollector
 243         (isi.xReferenceResolvedListener, css::uno::UNO_QUERY);
 244     xReferenceCollector->setReferenceCount( referenceCount );
 245 }
 246
 247 void XSecController::setX509Data(
 248         std::vector<std::pair<OUString, OUString>> & rX509IssuerSerials,
 249         std::vector<OUString> const& rX509Certificates)
 250 {
 251     if (m_vInternalSignatureInformations.empty())
 252     {
 253         SAL_INFO("xmlsecurity.helper","XSecController::setX509IssuerName: no signature");
 254         return;
 255     }
 256     InternalSignatureInformation &isi = m_vInternalSignatureInformations.back();
 257     SignatureInformation::X509Data data;
 258     // due to the excessive flexibility of the spec it's possible that there
 259     // is both a reference to a cert and the cert itself in one X509Data
 260     for (OUString const& it : rX509Certificates)
 261     {
 262         try
 263         {
 264             data.emplace_back();
 265             data.back().X509Certificate = it;
 266             uno::Reference<xml::crypto::XSecurityEnvironment> const xSecEnv(m_xSecurityContext->getSecurityEnvironment());
 267             uno::Reference<security::XCertificate> const xCert(xSecEnv->createCertificateFromAscii(it));
 268             if (!xCert.is())
 269             {
 270                 SAL_INFO("xmlsecurity.helper", "cannot parse X509Certificate");
 271                 continue; // will be handled in CheckX509Data
 272             }
 273             OUString const issuerName(xCert->getIssuerName());
 274             OUString const serialNumber(xmlsecurity::bigIntegerToNumericString(xCert->getSerialNumber()));
 275             auto const iter = std::find_if(rX509IssuerSerials.begin(), rX509IssuerSerials.end(),
 276                 [&](auto const& rX509IssuerSerial) {
 277                     return xmlsecurity::EqualDistinguishedNames(issuerName, rX509IssuerSerial.first, xmlsecurity::COMPAT_2ND)
 278                         && serialNumber == rX509IssuerSerial.second;
 279                 });
 280             if (iter != rX509IssuerSerials.end())
 281             {
 282                 data.back().X509IssuerName = iter->first;
 283                 data.back().X509SerialNumber = iter->second;
 284                 rX509IssuerSerials.erase(iter);
 285             }
 286         }
 287         catch (uno::Exception const&)
 288         {
 289             SAL_INFO("xmlsecurity.helper", "cannot parse X509Certificate");
 290         }
 291     }
 292     // now handle any that are left...
 293     for (auto const& it : rX509IssuerSerials)
 294     {
 295         data.emplace_back();
 296         data.back().X509IssuerName = it.first;
 297         data.back().X509SerialNumber = it.second;
 298     }
 299     if (!data.empty())
 300     {
 301         isi.signatureInfor.X509Datas.push_back(data);
 302     }
 303 }
 304
 305 void XSecController::setSignatureValue( OUString const & ouSignatureValue )
 306 {
 307     if (m_vInternalSignatureInformations.empty())
 308     {
 309         SAL_INFO("xmlsecurity.helper","XSecController::setSignatureValue: no signature");
 310         return;
 311     }
 312     InternalSignatureInformation &isi = m_vInternalSignatureInformations.back();
 313     isi.signatureInfor.ouSignatureValue = ouSignatureValue;
 314 }
 315
 316 void XSecController::setDigestValue( sal_Int32 nDigestID, OUString const & ouDigestValue )
 317 {
 318     if (m_vInternalSignatureInformations.empty())
 319     {
 320         SAL_INFO("xmlsecurity.helper","XSecController::setDigestValue: no signature");
 321         return;
 322     }
 323     InternalSignatureInformation &isi = m_vInternalSignatureInformations.back();
 324     if (isi.signatureInfor.vSignatureReferenceInfors.empty())
 325     {
 326         SAL_INFO("xmlsecurity.helper","XSecController::setDigestValue: no signature reference");
 327         return;
 328     }
 329     SignatureReferenceInformation &reference =
 330         isi.signatureInfor.vSignatureReferenceInfors.back();
 331     reference.nDigestID = nDigestID;
 332     reference.ouDigestValue = ouDigestValue;
 333 }
 334
 335 void XSecController::setGpgKeyID( OUString const & ouKeyID )
 336 {
 337     if (m_vInternalSignatureInformations.empty())
 338     {
 339         SAL_INFO("xmlsecurity.helper","XSecController::setGpgKeyID: no signature");
 340         return;
 341     }
 342     InternalSignatureInformation &isi = m_vInternalSignatureInformations.back();
 343     isi.signatureInfor.ouGpgKeyID = ouKeyID;
 344 }
 345
 346 void XSecController::setGpgCertificate( OUString const & ouGpgCert )
 347 {
 348     if (m_vInternalSignatureInformations.empty())
 349     {
 350         SAL_INFO("xmlsecurity.helper","XSecController::setGpgCertificate: no signature");
 351         return;
 352     }
 353     InternalSignatureInformation &isi = m_vInternalSignatureInformations.back();
 354     isi.signatureInfor.ouGpgCertificate = ouGpgCert;
 355 }
 356
 357 void XSecController::setGpgOwner( OUString const & ouGpgOwner )
 358 {
 359     if (m_vInternalSignatureInformations.empty())
 360     {
 361         SAL_INFO("xmlsecurity.helper","XSecController::setGpgOwner: no signature");
 362         return;
 363     }
 364     InternalSignatureInformation &isi = m_vInternalSignatureInformations.back();
 365     isi.signatureInfor.ouGpgOwner = ouGpgOwner;
 366 }
 367
 368 void XSecController::setDate(OUString const& rId, OUString const& ouDate)
 369 {
 370     if (m_vInternalSignatureInformations.empty())
 371     {
 372         SAL_INFO("xmlsecurity.helper","XSecController::setDate: no signature");
 373         return;
 374     }
 375     InternalSignatureInformation &isi = m_vInternalSignatureInformations.back();
 376     // there may be multiple timestamps in a signature - check them for consistency
 377     if (!isi.signatureInfor.ouDateTime.isEmpty()
 378         && isi.signatureInfor.ouDateTime != ouDate)
 379     {
 380         isi.signatureInfor.hasInconsistentSigningTime = true;
 381     }
 382     (void)utl::ISO8601parseDateTime( ouDate, isi.signatureInfor.stDateTime);
 383     isi.signatureInfor.ouDateTime = ouDate;
 384     if (!rId.isEmpty())
 385     {
 386         isi.signatureInfor.ouDateTimePropertyId = rId;
 387     }
 388 }
 389
 390 void XSecController::setDescription(OUString const& rId, OUString const& rDescription)
 391 {
 392     if (m_vInternalSignatureInformations.empty())
 393         return;
 394
 395     InternalSignatureInformation& rInformation = m_vInternalSignatureInformations.back();
 396     rInformation.signatureInfor.ouDescription = rDescription;
 397     if (!rId.isEmpty())
 398     {
 399         rInformation.signatureInfor.ouDescriptionPropertyId = rId;
 400     }
 401 }
 402
 403 void XSecController::setSignatureBytes(const uno::Sequence<sal_Int8>& rBytes)
 404 {
 405     if (m_vInternalSignatureInformations.empty())
 406         return;
 407
 408     InternalSignatureInformation& rInformation = m_vInternalSignatureInformations.back();
 409     rInformation.signatureInfor.aSignatureBytes = rBytes;
 410 }
 411
 412 void XSecController::setX509CertDigest(
 413     OUString const& rCertDigest, sal_Int32 const /*TODO nReferenceDigestID*/,
 414     std::u16string_view const& rX509IssuerName, std::u16string_view const& rX509SerialNumber)
 415 {
 416     if (m_vInternalSignatureInformations.empty())
 417         return;
 418
 419     InternalSignatureInformation& rInformation = m_vInternalSignatureInformations.back();
 420     for (auto & rData : rInformation.signatureInfor.X509Datas)
 421     {
 422         for (auto & it : rData)
 423         {
 424             if (xmlsecurity::EqualDistinguishedNames(it.X509IssuerName, rX509IssuerName, xmlsecurity::COMPAT_BOTH)
 425                 && it.X509SerialNumber == rX509SerialNumber)
 426             {
 427                 it.CertDigest = rCertDigest;
 428                 return;
 429             }
 430         }
 431     }
 432     // fall-back: read the actual certificates
 433     for (auto & rData : rInformation.signatureInfor.X509Datas)
 434     {
 435         for (auto & it : rData)
 436         {
 437             if (!it.X509Certificate.isEmpty())
 438             {
 439                 try
 440                 {
 441                     uno::Reference<xml::crypto::XSecurityEnvironment> const xSecEnv(m_xSecurityContext->getSecurityEnvironment());
 442                     uno::Reference<security::XCertificate> const xCert(xSecEnv->createCertificateFromAscii(it.X509Certificate));
 443                     if (!xCert.is())
 444                     {
 445                         SAL_INFO("xmlsecurity.helper", "cannot parse X509Certificate");
 446                     }
 447                     else if (xmlsecurity::EqualDistinguishedNames(xCert->getIssuerName(), rX509IssuerName, xmlsecurity::COMPAT_2ND)
 448                         && xmlsecurity::bigIntegerToNumericString(xCert->getSerialNumber()) == rX509SerialNumber)
 449                     {
 450                         it.CertDigest = rCertDigest;
 451                         // note: testInsertCertificate_PEM_DOCX requires these!
 452                         it.X509SerialNumber = rX509SerialNumber;
 453                         it.X509IssuerName = rX509IssuerName;
 454                         return;
 455                     }
 456                 }
 457                 catch (uno::Exception const&)
 458                 {
 459                     SAL_INFO("xmlsecurity.helper", "cannot parse X509Certificate");
 460                 }
 461             }
 462         }
 463     }
 464     if (!rInformation.signatureInfor.ouGpgCertificate.isEmpty())
 465     {
 466         SAL_INFO_IF(rCertDigest != rInformation.signatureInfor.ouGpgKeyID,
 467             "xmlsecurity.helper", "PGPKeyID vs CertDigest mismatch");
 468     }
 469     else
 470     {
 471         SAL_INFO("xmlsecurity.helper", "cannot find X509Data for CertDigest");
 472     }
 473 }
 474
 475 namespace {
 476 Reference<css::graphic::XGraphic> lcl_getGraphicFromString(std::u16string_view rImage)
 477 {
 478     Sequence<sal_Int8> seq;
 479     comphelper::Base64::decode(seq, rImage);
 480
 481     Reference< graphic::XGraphic > xGraphic;
 482     if( !seq.hasElements() )
 483         return Reference<css::graphic::XGraphic>();
 484
 485     Reference< graphic::XGraphicProvider > xGraphicProvider(
 486         graphic::GraphicProvider::create(comphelper::getProcessComponentContext()) );
 487     Reference< io::XInputStream > xInputStream( new ::comphelper::SequenceInputStream( seq ) );
 488
 489     Sequence< PropertyValue > aArgs{ comphelper::makePropertyValue(u"InputStream"_ustr, xInputStream) };
 490     xGraphic = xGraphicProvider->queryGraphic(aArgs);
 491
 492     return xGraphic;
 493 }
 494 }
 495
 496 void XSecController::setValidSignatureImage(std::u16string_view rValidSigImg)
 497 {
 498     if (m_vInternalSignatureInformations.empty() || rValidSigImg.empty())
 499         return;
 500
 501     InternalSignatureInformation& rInformation = m_vInternalSignatureInformations.back();
 502     rInformation.signatureInfor.aValidSignatureImage = lcl_getGraphicFromString(rValidSigImg);
 503 }
 504
 505 void XSecController::setInvalidSignatureImage(std::u16string_view rInvalidSigImg)
 506 {
 507     if (m_vInternalSignatureInformations.empty() || rInvalidSigImg.empty())
 508         return;
 509
 510     InternalSignatureInformation& rInformation = m_vInternalSignatureInformations.back();
 511     rInformation.signatureInfor.aInvalidSignatureImage = lcl_getGraphicFromString(rInvalidSigImg);
 512 }
 513
 514 void XSecController::setSignatureLineId(const OUString& rSignatureLineId)
 515 {
 516     if (m_vInternalSignatureInformations.empty())
 517         return;
 518
 519     InternalSignatureInformation& rInformation = m_vInternalSignatureInformations.back();
 520     rInformation.signatureInfor.ouSignatureLineId = rSignatureLineId;
 521 }
 522
 523 void XSecController::addEncapsulatedX509Certificate(const OUString& rEncapsulatedX509Certificate)
 524 {
 525     if (m_vInternalSignatureInformations.empty())
 526         return;
 527
 528     if (rEncapsulatedX509Certificate.isEmpty())
 529         return;
 530
 531     InternalSignatureInformation& rInformation = m_vInternalSignatureInformations.back();
 532     rInformation.signatureInfor.maEncapsulatedX509Certificates.insert(rEncapsulatedX509Certificate);
 533 }
 534
 535 void XSecController::setId( OUString const & ouId )
 536 {
 537     if (m_vInternalSignatureInformations.empty())
 538     {
 539         SAL_INFO("xmlsecurity.helper","XSecController::setId: no signature");
 540         return;
 541     }
 542     InternalSignatureInformation &isi = m_vInternalSignatureInformations.back();
 543     isi.signatureInfor.ouSignatureId = ouId;
 544 }
 545
 546 /* public: for signature verify */
 547 void XSecController::collectToVerify( std::u16string_view referenceId )
 548 {
 549     /* SAL_WARN_IF( !m_xSAXEventKeeper.is(), "xmlsecurity", "the SAXEventKeeper is NULL" ); */
 550
 551     if ( m_eStatusOfSecurityComponents != InitializationState::INITIALIZED )
 552     /*
 553      * if all security components are ready, verify the signature.
 554      */
 555         return;
 556
 557     bool bJustChainingOn = false;
 558     css::uno::Reference< css::xml::sax::XDocumentHandler > xHandler;
 559
 560     int i,j;
 561     int sigNum = m_vInternalSignatureInformations.size();
 562
 563     for (i=0; i<sigNum; ++i)
 564     {
 565         InternalSignatureInformation& isi = m_vInternalSignatureInformations[i];
 566         SignatureReferenceInformations& vReferenceInfors = isi.signatureInfor.vSignatureReferenceInfors;
 567         int refNum = vReferenceInfors.size();
 568
 569         for (j=0; j<refNum; ++j)
 570         {
 571             SignatureReferenceInformation &refInfor = vReferenceInfors[j];
 572
 573             if (refInfor.ouURI == referenceId)
 574             {
 575                 if (chainOn())
 576                 {
 577                     bJustChainingOn = true;
 578                     xHandler = m_xSAXEventKeeper->setNextHandler(nullptr);
 579                 }
 580
 581                 sal_Int32 nKeeperId = m_xSAXEventKeeper->addSecurityElementCollector(
 582                     css::xml::crypto::sax::ElementMarkPriority_BEFOREMODIFY, false );
 583
 584                 css::uno::Reference<css::xml::crypto::sax::XReferenceCollector> xReferenceCollector
 585                     ( isi.xReferenceResolvedListener, css::uno::UNO_QUERY );
 586
 587                 m_xSAXEventKeeper->setSecurityId(nKeeperId, isi.signatureInfor.nSecurityId);
 588                 m_xSAXEventKeeper->addReferenceResolvedListener( nKeeperId, isi.xReferenceResolvedListener);
 589                 xReferenceCollector->setReferenceId( nKeeperId );
 590
 591                 isi.vKeeperIds[j] = nKeeperId;
 592                 break;
 593             }
 594         }
 595     }
 596
 597     if ( bJustChainingOn )
 598     {
 599         m_xSAXEventKeeper->setNextHandler(xHandler);
 600     }
 601 }
 602
 603 void XSecController::addSignature( sal_Int32 nSignatureId )
 604 {
 605     SAL_WARN_IF( !m_xSecParser.is(), "xmlsecurity.helper", "No XSecParser initialized" );
 606
 607     m_nReservedSignatureId = nSignatureId;
 608     m_bVerifyCurrentSignature = true;
 609 }
 610
 611 css::uno::Reference< css::xml::sax::XDocumentHandler > const & XSecController::createSignatureReader(XMLSignatureHelper& rXMLSignatureHelper, sal_Int32 nType)
 612 {
 613     if (nType == embed::StorageFormats::OFOPXML)
 614         m_xSecParser = new OOXMLSecParser(rXMLSignatureHelper, this);
 615     else
 616         m_xSecParser = new XSecParser(rXMLSignatureHelper, this);
 617     css::uno::Reference< css::lang::XInitialization > xInitialization(m_xSecParser, uno::UNO_QUERY);
 618
 619     setSAXChainConnector(xInitialization);
 620
 621     return m_xSecParser;
 622 }
 623
 624 void XSecController::releaseSignatureReader()
 625 {
 626     clearSAXChainConnector( );
 627     m_xSecParser.clear();
 628 }
 629
 630 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */