xmlsecurity/source/helper/xmlsignaturehelper.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: xmlsignaturehelper.cxx,v $
  10  * $Revision: 1.29 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_xmlsecurity.hxx"
  33
  34 #include <xmlsecurity/xmlsignaturehelper.hxx>
  35 #include <xmlsecurity/documentsignaturehelper.hxx>
  36 #include <xsecctl.hxx>
  37
  38 #include <xmlsignaturehelper2.hxx>
  39
  40 #include <tools/stream.hxx>
  41 #include <tools/debug.hxx>
  42
  43 #include <xmloff/attrlist.hxx>
  44
  45 #include <com/sun/star/io/XOutputStream.hpp>
  46 #include <com/sun/star/io/XInputStream.hpp>
  47 #include <com/sun/star/io/XActiveDataSource.hpp>
  48 #include <com/sun/star/lang/XComponent.hpp>
  49 #include <com/sun/star/security/SerialNumberAdapter.hpp>
  50 #include <com/sun/star/beans/XPropertySet.hpp>
  51
  52 #include <tools/date.hxx>
  53 #include <tools/time.hxx>
  54
  55 //MM : search for the default profile
  56 //#include <unotools/streamhelper.hxx>
  57 //MM : end
  58
  59 /* SEInitializer component */
  60 #define SEINITIALIZER_COMPONENT "com.sun.star.xml.crypto.SEInitializer"
  61
  62 #define TAG_DOCUMENTSIGNATURES  "document-signatures"
  63 #define NS_DOCUMENTSIGNATURES   "http://openoffice.org/2004/documentsignatures"
  64 #define NS_DOCUMENTSIGNATURES_ODF_1_2 "urn:oasis:names:tc:opendocument:xmlns:digitalsignature:1.0"
  65
  66 using namespace ::com::sun::star;
  67 using namespace ::com::sun::star::uno;
  68
  69 XMLSignatureHelper::XMLSignatureHelper( const uno::Reference< uno::XComponentContext >& rxCtx)
  70     : mxCtx(rxCtx), mbODFPre1_2(false)
  71 {
  72     mpXSecController = new XSecController(rxCtx);
  73     mxSecurityController = mpXSecController;
  74     mbError = false;
  75 }
  76
  77 XMLSignatureHelper::~XMLSignatureHelper()
  78 {
  79     if ( mxSEInitializer.is() && mxSecurityContext.is() )
  80         mxSEInitializer->freeSecurityContext( mxSecurityContext );
  81 }
  82
  83 bool XMLSignatureHelper::Init( const rtl::OUString& rTokenPath )
  84 {
  85     DBG_ASSERT( !mxSEInitializer.is(), "XMLSignatureHelper::Init - mxSEInitializer already set!" );
  86     DBG_ASSERT( !mxSecurityContext.is(), "XMLSignatureHelper::Init - mxSecurityContext already set!" );
  87
  88     ImplCreateSEInitializer();
  89
  90     if ( mxSEInitializer.is() )
  91         mxSecurityContext = mxSEInitializer->createSecurityContext( rTokenPath );
  92
  93     return mxSecurityContext.is();
  94 }
  95
  96 void XMLSignatureHelper::ImplCreateSEInitializer()
  97 {
  98     rtl::OUString sSEInitializer(rtl::OUString::createFromAscii( SEINITIALIZER_COMPONENT ));
  99     uno::Reference< lang::XMultiComponentFactory > xMCF( mxCtx->getServiceManager() );
 100     mxSEInitializer = uno::Reference< com::sun::star::xml::crypto::XSEInitializer > (
 101         xMCF->createInstanceWithContext( sSEInitializer,  mxCtx ), uno::UNO_QUERY );
 102 }
 103
 104 void XMLSignatureHelper::SetUriBinding( com::sun::star::uno::Reference< com::sun::star::xml::crypto::XUriBinding >& rxUriBinding )
 105 {
 106     mxUriBinding = rxUriBinding;
 107 }
 108
 109 com::sun::star::uno::Reference< com::sun::star::xml::crypto::XUriBinding > XMLSignatureHelper::GetUriBinding() const
 110 {
 111     return mxUriBinding;
 112 }
 113
 114 void XMLSignatureHelper::SetStorage(
 115     const Reference < css::embed::XStorage >& rxStorage,
 116     ::rtl::OUString sODFVersion)
 117 {
 118     DBG_ASSERT( !mxUriBinding.is(), "SetStorage - UriBinding already set!" );
 119     mxUriBinding = new UriBindingHelper( rxStorage );
 120     DBG_ASSERT(rxStorage.is(), "SetStorage - empty storage!");
 121     mbODFPre1_2 = DocumentSignatureHelper::isODFPre_1_2(sODFVersion);
 122 }
 123
 124
 125 void XMLSignatureHelper::SetStartVerifySignatureHdl( const Link& rLink )
 126 {
 127     maStartVerifySignatureHdl = rLink;
 128 }
 129
 130
 131 void XMLSignatureHelper::StartMission()
 132 {
 133     if ( !mxUriBinding.is() )
 134         mxUriBinding = new UriBindingHelper();
 135
 136     mpXSecController->startMission( mxUriBinding, mxSecurityContext );
 137 }
 138
 139 void XMLSignatureHelper::EndMission()
 140 {
 141     mpXSecController->endMission();
 142 }
 143
 144 sal_Int32 XMLSignatureHelper::GetNewSecurityId()
 145 {
 146     return mpXSecController->getNewSecurityId();
 147 }
 148
 149 void XMLSignatureHelper::SetX509Certificate(
 150         sal_Int32 nSecurityId,
 151         const rtl::OUString& ouX509IssuerName,
 152         const rtl::OUString& ouX509SerialNumber,
 153         const rtl::OUString& ouX509Cert)
 154 {
 155     mpXSecController->setX509Certificate(
 156         nSecurityId,
 157         ouX509IssuerName,
 158         ouX509SerialNumber,
 159         ouX509Cert);
 160 }
 161
 162 void XMLSignatureHelper::SetX509Certificate(
 163         sal_Int32 nSecurityId,
 164         sal_Int32 nSecurityEnvironmentIndex,
 165         const rtl::OUString& ouX509IssuerName,
 166         const rtl::OUString& ouX509SerialNumber,
 167         const rtl::OUString& ouX509Cert)
 168 {
 169     mpXSecController->setX509Certificate(
 170         nSecurityId,
 171         nSecurityEnvironmentIndex,
 172         ouX509IssuerName,
 173         ouX509SerialNumber,
 174         ouX509Cert);
 175 }
 176
 177 void XMLSignatureHelper::SetDateTime( sal_Int32 nSecurityId, const Date& rDate, const Time& rTime )
 178 {
 179     /*
 180     rtl::OUString aDate = String::CreateFromInt32( rDate.GetDate() );
 181     rtl::OUString aTime = String::CreateFromInt32( rTime.GetTime() );
 182     mpXSecController->setDateTime( nSecurityId, aDate, aTime );
 183     */
 184     ::com::sun::star::util::DateTime stDateTime;
 185     stDateTime.HundredthSeconds = (::sal_uInt16)rTime.Get100Sec();
 186     stDateTime.Seconds = (::sal_uInt16)rTime.GetSec();
 187     stDateTime.Minutes = (::sal_uInt16)rTime.GetMin();
 188     stDateTime.Hours = (::sal_uInt16)rTime.GetHour();
 189     stDateTime.Day = (::sal_uInt16)rDate.GetDay();
 190     stDateTime.Month = (::sal_uInt16)rDate.GetMonth();
 191     stDateTime.Year = (::sal_uInt16)rDate.GetYear();
 192     mpXSecController->setDate( nSecurityId, stDateTime );
 193 }
 194
 195 void XMLSignatureHelper::AddForSigning( sal_Int32 nSecurityId, const rtl::OUString& uri, const rtl::OUString& objectURL, sal_Bool bBinary )
 196 {
 197     mpXSecController->signAStream( nSecurityId, uri, objectURL, bBinary );
 198 }
 199
 200
 201 uno::Reference<xml::sax::XDocumentHandler> XMLSignatureHelper::CreateDocumentHandlerWithHeader(
 202     const com::sun::star::uno::Reference< com::sun::star::io::XOutputStream >& xOutputStream )
 203 {
 204     /*
 205      * get SAX writer component
 206      */
 207     uno::Reference< lang::XMultiComponentFactory > xMCF( mxCtx->getServiceManager() );
 208     uno::Reference< io::XActiveDataSource > xSaxWriter(
 209         xMCF->createInstanceWithContext(rtl::OUString::createFromAscii(
 210             "com.sun.star.xml.sax.Writer"), mxCtx ), uno::UNO_QUERY );
 211
 212     DBG_ASSERT( xSaxWriter.is(), "can't instantiate XML writer" );
 213
 214     /*
 215      * connect XML writer to output stream
 216      */
 217     xSaxWriter->setOutputStream( xOutputStream );
 218
 219     /*
 220      * prepare document handler
 221      */
 222     uno::Reference<xml::sax::XDocumentHandler>
 223         xDocHandler( xSaxWriter,uno::UNO_QUERY);
 224
 225     /*
 226      * write the xml context for signatures
 227      */
 228     rtl::OUString tag_AllSignatures(RTL_CONSTASCII_USTRINGPARAM(TAG_DOCUMENTSIGNATURES));
 229
 230     SvXMLAttributeList *pAttributeList = new SvXMLAttributeList();
 231     rtl::OUString sNamespace;
 232     if (mbODFPre1_2)
 233         sNamespace = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(NS_DOCUMENTSIGNATURES));
 234     else
 235         sNamespace = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(NS_DOCUMENTSIGNATURES_ODF_1_2));
 236
 237     pAttributeList->AddAttribute(
 238         rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(ATTR_XMLNS)),
 239         sNamespace);
 240
 241     xDocHandler->startDocument();
 242     xDocHandler->startElement(
 243         tag_AllSignatures,
 244         uno::Reference< com::sun::star::xml::sax::XAttributeList > (pAttributeList));
 245
 246     return xDocHandler;
 247 }
 248
 249 void XMLSignatureHelper::CloseDocumentHandler( const uno::Reference<xml::sax::XDocumentHandler>& xDocumentHandler )
 250 {
 251     rtl::OUString tag_AllSignatures(RTL_CONSTASCII_USTRINGPARAM(TAG_DOCUMENTSIGNATURES));
 252     xDocumentHandler->endElement( tag_AllSignatures );
 253     xDocumentHandler->endDocument();
 254 }
 255
 256 void XMLSignatureHelper::ExportSignature(
 257     const uno::Reference< xml::sax::XDocumentHandler >& xDocumentHandler,
 258     const SignatureInformation& signatureInfo )
 259 {
 260     mpXSecController->exportSignature(xDocumentHandler, signatureInfo);
 261 }
 262
 263 bool XMLSignatureHelper::CreateAndWriteSignature( const uno::Reference< xml::sax::XDocumentHandler >& xDocumentHandler )
 264 {
 265     mbError = false;
 266
 267     /*
 268      * create a signature listener
 269      */
 270 /*
 271     ImplXMLSignatureListener* pSignatureListener = new ImplXMLSignatureListener(
 272                                                     LINK( this, XMLSignatureHelper, SignatureCreationResultListener ),
 273                                                     LINK( this, XMLSignatureHelper, SignatureVerifyResultListener ),
 274                                                     LINK( this, XMLSignatureHelper, StartVerifySignatureElement ) );
 275 */
 276     /*
 277      * configure the signature creation listener
 278      */
 279     //mpXSecController->setSignatureCreationResultListener( pSignatureListener );
 280
 281     /*
 282      * write signatures
 283      */
 284     if ( !mpXSecController->WriteSignature( xDocumentHandler ) )
 285     {
 286         mbError = true;
 287     }
 288
 289     /*
 290      * clear up the signature creation listener
 291      */
 292     //mpXSecController->setSignatureCreationResultListener( NULL );
 293
 294     return !mbError;
 295 }
 296
 297 bool XMLSignatureHelper::CreateAndWriteSignature( const com::sun::star::uno::Reference< com::sun::star::io::XOutputStream >& xOutputStream )
 298 {
 299     uno::Reference<xml::sax::XDocumentHandler> xDocHandler
 300         = CreateDocumentHandlerWithHeader(xOutputStream);
 301
 302     bool rc = CreateAndWriteSignature( xDocHandler );
 303
 304     CloseDocumentHandler(xDocHandler);
 305
 306     return rc;
 307 }
 308
 309 bool XMLSignatureHelper::ReadAndVerifySignature( const com::sun::star::uno::Reference< com::sun::star::io::XInputStream >& xInputStream )
 310 {
 311     mbError = false;
 312
 313     DBG_ASSERT(xInputStream.is(), "input stream missing");
 314
 315     /*
 316      * prepare ParserInputSrouce
 317      */
 318     xml::sax::InputSource aParserInput;
 319     // aParserInput.sSystemId = ouName;
 320     aParserInput.aInputStream = xInputStream;
 321
 322     /*
 323      * get SAX parser component
 324      */
 325     uno::Reference< lang::XMultiComponentFactory > xMCF( mxCtx->getServiceManager() );
 326     uno::Reference< xml::sax::XParser > xParser(
 327         xMCF->createInstanceWithContext(
 328             rtl::OUString::createFromAscii("com.sun.star.xml.sax.Parser"), mxCtx ),
 329         uno::UNO_QUERY );
 330
 331     DBG_ASSERT( xParser.is(), "Can't create parser" );
 332
 333     /*
 334      * create a signature reader
 335      */
 336     uno::Reference< xml::sax::XDocumentHandler > xHandler
 337         = mpXSecController->createSignatureReader( );
 338
 339     /*
 340      * create a signature listener
 341      */
 342     ImplXMLSignatureListener* pSignatureListener = new ImplXMLSignatureListener(
 343                                                     LINK( this, XMLSignatureHelper, SignatureCreationResultListener ),
 344                                                     LINK( this, XMLSignatureHelper, SignatureVerifyResultListener ),
 345                                                     LINK( this, XMLSignatureHelper, StartVerifySignatureElement ) );
 346
 347     /*
 348      * configure the signature verify listener
 349      */
 350     //mpXSecController->setSignatureVerifyResultListener( pSignatureListener );
 351
 352     /*
 353      * setup the connection:
 354      * Parser -> SignatureListener -> SignatureReader
 355      */
 356     pSignatureListener->setNextHandler(xHandler);
 357     xParser->setDocumentHandler( pSignatureListener );
 358
 359     /*
 360      * parser the stream
 361      */
 362     try
 363     {
 364         xParser->parseStream( aParserInput );
 365     }
 366     catch( xml::sax::SAXParseException& )
 367     {
 368         mbError = true;
 369     }
 370     catch( xml::sax::SAXException& )
 371     {
 372         mbError = true;
 373     }
 374     catch( com::sun::star::io::IOException& )
 375     {
 376         mbError = true;
 377     }
 378     catch( uno::Exception& )
 379     {
 380         mbError = true;
 381     }
 382
 383     /*
 384      * clear up the connection
 385      */
 386     pSignatureListener->setNextHandler( NULL );
 387
 388     /*
 389      * clear up the signature verify listener
 390      */
 391     //mpXSecController->setSignatureVerifyResultListener( NULL );
 392
 393     /*
 394      * release the signature reader
 395      */
 396     mpXSecController->releaseSignatureReader( );
 397
 398     return !mbError;
 399 }
 400
 401 SignatureInformation XMLSignatureHelper::GetSignatureInformation( sal_Int32 nSecurityId ) const
 402 {
 403     return mpXSecController->getSignatureInformation( nSecurityId );
 404 }
 405
 406 SignatureInformations XMLSignatureHelper::GetSignatureInformations() const
 407 {
 408     return mpXSecController->getSignatureInformations();
 409 }
 410
 411 uno::Reference< ::com::sun::star::xml::crypto::XSecurityEnvironment > XMLSignatureHelper::GetSecurityEnvironment()
 412 {
 413     return (mxSecurityContext.is()?(mxSecurityContext->getSecurityEnvironment()): uno::Reference< ::com::sun::star::xml::crypto::XSecurityEnvironment >());
 414 }
 415
 416 uno::Reference< ::com::sun::star::xml::crypto::XSecurityEnvironment > XMLSignatureHelper::GetSecurityEnvironmentByIndex(sal_Int32 nId)
 417 {
 418     return (mxSecurityContext.is()?(mxSecurityContext->getSecurityEnvironmentByIndex(nId)): uno::Reference< ::com::sun::star::xml::crypto::XSecurityEnvironment >());
 419 }
 420
 421 sal_Int32 XMLSignatureHelper::GetSecurityEnvironmentNumber()
 422 {
 423     return (mxSecurityContext.is()?(mxSecurityContext->getSecurityEnvironmentNumber()): 0);
 424 }
 425
 426
 427 /*
 428 void XMLSignatureHelper::createSecurityContext( rtl::OUString tokenPath )
 429 {
 430     if ( !mxSEInitializer.is() )
 431         ImplCreateSEInitializer();
 432
 433     mxSecurityContext = mxSEInitializer->createSecurityContext(tokenPath);
 434 }
 435
 436 void XMLSignatureHelper::freeSecurityContext()
 437 {
 438     if ( !mxSEInitializer.is() )
 439         ImplCreateSEInitializer();
 440
 441     mxSEInitializer->freeSecurityContext( mxSecurityContext );
 442 }
 443 */
 444
 445 IMPL_LINK( XMLSignatureHelper, SignatureCreationResultListener, XMLSignatureCreationResult*, pResult )
 446 {
 447     maCreationResults.insert( maCreationResults.begin() + maCreationResults.size(), *pResult );
 448     if ( pResult->nSignatureCreationResult != com::sun::star::xml::crypto::SecurityOperationStatus_OPERATION_SUCCEEDED )
 449         mbError = true;
 450     return 0;
 451 }
 452
 453 IMPL_LINK( XMLSignatureHelper, SignatureVerifyResultListener, XMLSignatureVerifyResult*, pResult )
 454 {
 455     maVerifyResults.insert( maVerifyResults.begin() + maVerifyResults.size(), *pResult );
 456     if ( pResult->nSignatureVerifyResult != com::sun::star::xml::crypto::SecurityOperationStatus_OPERATION_SUCCEEDED )
 457         mbError = true;
 458     return 0;
 459 }
 460
 461 IMPL_LINK( XMLSignatureHelper, StartVerifySignatureElement, const uno::Reference< com::sun::star::xml::sax::XAttributeList >*, pAttrs )
 462 {
 463     if ( !maStartVerifySignatureHdl.IsSet() || maStartVerifySignatureHdl.Call( (void*)pAttrs ) )
 464     {
 465         sal_Int32 nSignatureId = mpXSecController->getNewSecurityId();
 466         mpXSecController->addSignature( nSignatureId );
 467     }
 468
 469     return 0;
 470 }