mir/libreoffice
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
9e997f79d05ae5be084bed24758f38d4c49328c3
libreoffice/xmlsecurity/source/helper/xsecctl.cxx

1360 lines
43 KiB
C++
Raw Normal View History

libxmlsec
2004-07-12 12:15:31 +00:00
/*************************************************************************
*
* $RCSfile: xsecctl.cxx,v $
*
* $Revision: 1.1.1.1 $
*
* last change: $Author: mt $ $Date: 2004-07-12 13:15:22 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
*
* - GNU Lesser General Public License Version 2.1
* - Sun Industry Standards Source License Version 1.1
*
* Sun Microsystems Inc., October, 2000
*
* GNU Lesser General Public License Version 2.1
* =============================================
* Copyright 2000 by Sun Microsystems, Inc.
* 901 San Antonio Road, Palo Alto, CA 94303, USA
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
*
* Sun Industry Standards Source License Version 1.1
* =================================================
* The contents of this file are subject to the Sun Industry Standards
* Source License Version 1.1 (the "License"); You may not use this file
* except in compliance with the License. You may obtain a copy of the
* License at http://www.openoffice.org/license.html.
*
* Software provided under this License is provided on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
* WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
* MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
* See the License for the specific provisions governing your rights and
* obligations concerning the Software.
*
* The Initial Developer of the Original Code is: Sun Microsystems, Inc.
*
* Copyright: 2000 by Sun Microsystems, Inc.
*
* All Rights Reserved.
*
* Contributor(s): _______________________________________
*
*
************************************************************************/
#include <xsecctl.hxx>
#ifndef _TOOLS_DEBUG_HXX //autogen wg. DBG_ASSERT
#include <tools/debug.hxx>
#endif
#include <com/sun/star/xml/crypto/sax/ElementMarkPriority.hpp>
#include <com/sun/star/xml/crypto/sax/XReferenceResolvedBroadcaster.hpp>
#include <com/sun/star/xml/crypto/sax/XMissionTaker.hpp>
#include <com/sun/star/xml/crypto/sax/XReferenceCollector.hpp>
#include <com/sun/star/xml/crypto/sax/XSAXEventKeeperStatusChangeBroadcaster.hpp>
#include <com/sun/star/xml/crypto/sax/SignatureVerifyResult.hpp>
#include <com/sun/star/xml/crypto/sax/SignatureCreationResult.hpp>
#include <xmloff/attrlist.hxx>
namespace cssu = com::sun::star::uno;
namespace cssl = com::sun::star::lang;
namespace cssxc = com::sun::star::xml::crypto;
namespace cssxs = com::sun::star::xml::sax;
namespace cssxw = com::sun::star::xml::wrapper;
namespace cssb = com::sun::star::beans;
/* bridge component names */
#define XMLSIGNATURE_COMPONENT "com.sun.star.xml.crypto.XMLSignature"
#define XMLDOCUMENTWRAPPER_COMPONENT "com.sun.star.xml.wrapper.XMLDocumentWrapper"
/* xml security framework components */
#define SAXEVENTKEEPER_COMPONENT "com.sun.star.xml.crypto.sax.SAXEventKeeper"
/* string for package protocol */
#define PACKAGEPROTOCOL "vnd.sun.star.Package:"
XSecController::XSecController( )
:m_nNextSecurityId(1),
m_bIsSAXEventKeeperSticky(false),
m_bIsSAXEventKeeperConnected(false),
m_nStatusOfSecurityComponents(UNINITIALIZED),
m_pErrorMessage(NULL),
m_pXSecParser(NULL)
{
}
XSecController::~XSecController()
{
}
/*
* private methods
*/
int XSecController::findSignatureInfor( sal_Int32 nSecurityId)
/****** XSecController/findSignatureInfor *************************************
*
* NAME
* findSignatureInfor -- find SignatureInformation struct for a particular
* signature
*
* SYNOPSIS
* index = findSignatureInfor( nSecurityId );
*
* FUNCTION
* see NAME.
*
* INPUTS
* nSecurityId - the signature's id
*
* RESULT
* index - the index of the signature, or -1 when no such signature
* existing
*
* HISTORY
* 08.05.2004 - implemented
*
* AUTHOR
* Michael Mi
* Email: michael.mi@sun.com
******************************************************************************/
{
int i;
int size = m_vInternalSignatureInformations.size();
for (i=0; i<size; ++i)
{
if (m_vInternalSignatureInformations[i].signatureInfor.nSecurityId == nSecurityId)
{
return i;
}
}
return -1;
}
void XSecController::createXSecComponent( )
/****** XSecController/createXSecComponent ************************************
*
* NAME
* bResult = createXSecComponent -- creates xml security components
*
* SYNOPSIS
* createXSecComponent( );
*
* FUNCTION
* Creates xml security components, including:
* 1. an xml signature bridge component ( Java based or C based)
* 2. an XMLDocumentWrapper component ( Java based or C based)
* 3. a SAXEventKeeper component
*
* INPUTS
* empty
*
* RESULT
* empty
*
* HISTORY
* 05.01.2004 - implemented
*
* AUTHOR
* Michael Mi
* Email: michael.mi@sun.com
******************************************************************************/
{
rtl::OUString sSAXEventKeeper(rtl::OUString::createFromAscii( SAXEVENTKEEPER_COMPONENT ));
rtl::OUString sXMLSignature(rtl::OUString::createFromAscii( XMLSIGNATURE_COMPONENT ));
rtl::OUString sXMLDocument(rtl::OUString::createFromAscii( XMLDOCUMENTWRAPPER_COMPONENT ));
/*
* marks all security components are not available.
*/
m_nStatusOfSecurityComponents = FAILTOINITIALIZED;
m_xXMLSignature = NULL;
m_xXMLDocumentWrapper = NULL;
m_xSAXEventKeeper = NULL;
m_xXMLSignature = cssu::Reference< cssxc::XXMLSignature >(
mxMSF->createInstance( sXMLSignature ),
cssu::UNO_QUERY );
bool bSuccess = (0!=m_xXMLSignature.is());
if ( bSuccess )
/*
* XMLSignature created successfully.
*/
{
m_xXMLDocumentWrapper = cssu::Reference< cssxw::XXMLDocumentWrapper >(
mxMSF->createInstance( sXMLDocument ),
cssu::UNO_QUERY );
}
bSuccess &= (0!=m_xXMLDocumentWrapper.is());
if ( bSuccess )
/*
* XMLDocumentWrapper created successfully.
*/
{
m_xSAXEventKeeper = cssu::Reference< cssxc::sax::XSecuritySAXEventKeeper >(
mxMSF->createInstance( sSAXEventKeeper ),
cssu::UNO_QUERY );
}
bSuccess &= (0!=m_xSAXEventKeeper.is());
if (bSuccess)
/*
* SAXEventKeeper created successfully.
*/
{
cssu::Reference< cssl::XInitialization > xInitialization(m_xSAXEventKeeper, cssu::UNO_QUERY);
cssu::Sequence <cssu::Any> arg(1);
arg[0] = cssu::makeAny(m_xXMLDocumentWrapper);
xInitialization->initialize(arg);
cssu::Reference<cssxc::sax::XSAXEventKeeperStatusChangeBroadcaster>
xSAXEventKeeperStatusChangeBroadcaster(m_xSAXEventKeeper, cssu::UNO_QUERY);
cssu::Reference< cssxc::sax::XSAXEventKeeperStatusChangeListener >
xStatusChangeListener = this;
xSAXEventKeeperStatusChangeBroadcaster
->addXSAXEventKeeperStatusChangeListener( xStatusChangeListener );
m_nStatusOfSecurityComponents = INITIALIZED;
}
}
bool XSecController::chainOn( bool bRetrievingLastEvent )
/****** XSecController/chainOn ************************************************
*
* NAME
* chainOn -- tyies to connect the SAXEventKeeper with the SAX chain.
*
* SYNOPSIS
* bJustChainingOn = chainOn( bRetrievingLastEvent );
*
* FUNCTION
* First, checks whether the SAXEventKeeper is on the SAX chain. If not,
* creates xml security components, and chains the SAXEventKeeper into
* the SAX chain.
* Before being chained in, the SAXEventKeeper needs to receive all
* missed key SAX events, which can promise the DOM tree bufferred by the
* SAXEventKeeper has the same structure with the original document.
*
* INPUTS
* bRetrievingLastEvent - whether to retrieve the last key SAX event from
* the ElementStackKeeper.
*
* RESULT
* bJustChainingOn - whether the SAXEventKeeper is just chained into the
* SAX chain.
*
* NOTES
* Sometimes, the last key SAX event can't be transferred to the
* SAXEventKeeper together.
* For instance, at the time an referenced element is detected, the
* startElement event has already been reserved by the ElementStackKeeper.
* Meanwhile, an ElementCollector needs to be created before the
* SAXEventKeeper receives that startElement event.
* So for the SAXEventKeeper, it needs to receive all missed key SAX
* events except that startElement event, then adds a new
* ElementCollector, then receives that startElement event.
*
* HISTORY
* 05.01.2004 - implemented
*
* AUTHOR
* Michael Mi
* Email: michael.mi@sun.com
******************************************************************************/
{
bool rc = false;
if (!m_bIsSAXEventKeeperSticky && !m_bIsSAXEventKeeperConnected)
{
if ( m_nStatusOfSecurityComponents == UNINITIALIZED )
{
createXSecComponent();
}
if ( m_nStatusOfSecurityComponents == INITIALIZED )
/*
* if all security components are ready, chains on the SAXEventKeeper
*/
{
/*
* disconnect the SAXEventKeeper with its current output handler,
* to make sure no SAX event is forwarded during the connecting
* phase.
*/
m_xSAXEventKeeper->setNextHandler( NULL );
cssu::Reference< cssxs::XDocumentHandler > xSEKHandler(m_xSAXEventKeeper, cssu::UNO_QUERY);
/*
* connects the previous document handler on the SAX chain
*/
if ( m_xPreviousNodeOnSAXChain.is() )
{
if ( m_bIsPreviousNodeInitializable )
{
cssu::Reference< cssl::XInitialization > xInitialization
(m_xPreviousNodeOnSAXChain, cssu::UNO_QUERY);
cssu::Sequence<cssu::Any> aArgs( 1 );
aArgs[0] <<= xSEKHandler;
xInitialization->initialize(aArgs);
}
else
{
cssu::Reference< cssxs::XParser > xParser
(m_xPreviousNodeOnSAXChain, cssu::UNO_QUERY);
xParser->setDocumentHandler( xSEKHandler );
}
}
/*
* get missed key SAX events
*/
if (m_xElementStackKeeper.is())
{
m_xElementStackKeeper->retrieve(xSEKHandler, bRetrievingLastEvent);
/*
* now the ElementStackKeeper can stop its work, because the
* SAXEventKeeper is on the SAX chain, no SAX events will be
* missed.
*/
m_xElementStackKeeper->stop();
}
/*
* connects the next document handler on the SAX chain
*/
m_xSAXEventKeeper->setNextHandler( m_xNextNodeOnSAXChain );
m_bIsSAXEventKeeperConnected = true;
rc = true;
}
}
return rc;
}
void XSecController::chainOff()
/****** XSecController/chainOff ***********************************************
*
* NAME
* chainOff -- disconnects the SAXEventKeeper from the SAX chain.
*
* SYNOPSIS
* chainOff( );
*
* FUNCTION
* See NAME.
*
* INPUTS
* empty
*
* RESULT
* empty
*
* HISTORY
* 05.01.2004 - implemented
*
* AUTHOR
* Michael Mi
* Email: michael.mi@sun.com
******************************************************************************/
{
if (!m_bIsSAXEventKeeperSticky )
{
if (m_bIsSAXEventKeeperConnected)
{
m_xSAXEventKeeper->setNextHandler( NULL );
if ( m_xPreviousNodeOnSAXChain.is() )
{
if ( m_bIsPreviousNodeInitializable )
{
cssu::Reference< cssl::XInitialization > xInitialization
(m_xPreviousNodeOnSAXChain, cssu::UNO_QUERY);
cssu::Sequence<cssu::Any> aArgs( 1 );
aArgs[0] <<= m_xNextNodeOnSAXChain;
xInitialization->initialize(aArgs);
}
else
{
cssu::Reference< cssxs::XParser > xParser(m_xPreviousNodeOnSAXChain, cssu::UNO_QUERY);
xParser->setDocumentHandler( m_xNextNodeOnSAXChain );
}
}
if (m_xElementStackKeeper.is())
{
/*
* start the ElementStackKeeper to reserve any possible
* missed key SAX events
*/
m_xElementStackKeeper->start();
}
m_bIsSAXEventKeeperConnected = false;
}
}
}
void XSecController::checkChainingStatus()
/****** XSecController/checkChainingStatus ************************************
*
* NAME
* checkChainingStatus -- connects or disconnects the SAXEventKeeper
* according to the current situation.
*
* SYNOPSIS
* checkChainingStatus( );
*
* FUNCTION
* The SAXEventKeeper is chained into the SAX chain, when:
* 1. some element is being collected, or
* 2. the SAX event stream is blocking.
* Otherwise, chain off the SAXEventKeeper.
*
* INPUTS
* empty
*
* RESULT
* empty
*
* HISTORY
* 05.01.2004 - implemented
*
* AUTHOR
* Michael Mi
* Email: michael.mi@sun.com
******************************************************************************/
{
if ( m_bIsCollectingElement || m_bIsBlocking )
{
chainOn(true);
}
else
{
chainOff();
}
}
void XSecController::initializeSAXChain()
/****** XSecController/initializeSAXChain *************************************
*
* NAME
* initializeSAXChain -- initializes the SAX chain according to the
* current setting.
*
* SYNOPSIS
* initializeSAXChain( );
*
* FUNCTION
* Initializes the SAX chain, if the SAXEventKeeper is asked to be always
* on the SAX chain, chains it on. Otherwise, starts the
* ElementStackKeeper to reserve key SAX events.
*
* INPUTS
* empty
*
* RESULT
* empty
*
* HISTORY
* 05.01.2004 - implemented
*
* AUTHOR
* Michael Mi
* Email: michael.mi@sun.com
******************************************************************************/
{
m_bIsSAXEventKeeperConnected = false;
m_bIsCollectingElement = false;
m_bIsBlocking = false;
if (m_xElementStackKeeper.is())
{
/*
* starts the ElementStackKeeper
*/
m_xElementStackKeeper->start();
}
chainOff();
}
cssu::Reference< com::sun::star::io::XInputStream >
XSecController::getObjectInputStream( const rtl::OUString& objectURL )
/****** XSecController/getObjectInputStream ************************************
*
* NAME
* getObjectInputStream -- get a XInputStream interface from a SvStorage
*
* SYNOPSIS
* xInputStream = getObjectInputStream( objectURL );
*
* FUNCTION
* See NAME.
*
* INPUTS
* objectURL - the object uri
*
* RESULT
* xInputStream - the XInputStream interface
*
* HISTORY
* 15.04.2004 - implemented
*
* AUTHOR
* Michael Mi
* Email: michael.mi@sun.com
******************************************************************************/
{
cssu::Reference< com::sun::star::io::XInputStream > xObjectInputStream;
DBG_ASSERT( m_xUriBinding.is(), "Need XUriBinding!" );
xObjectInputStream = m_xUriBinding->getUriBinding(objectURL);
return xObjectInputStream;
}
#if 0
sal_Int32 XSecController::getFastPropertyIndex(sal_Int32 nHandle) const
/****** XSecController/getFastPropertyIndex ***********************************
*
* NAME
* getFastPropertyIndex -- gets the index of a particular fast property
*
* SYNOPSIS
* nIndex = getFastPropertyIndex( nHandle );
*
* FUNCTION
* See NAME.
*
* INPUTS
* nHandle - the key for the fast property
*
* RESULT
* nIndex - the index of the fast property, or -1
* if the key is not found.
*
* HISTORY
* 05.01.2004 - implemented
*
* AUTHOR
* Michael Mi
* Email: michael.mi@sun.com
******************************************************************************/
{
std::vector< sal_Int32 >::const_iterator ii = m_vFastPropertyIndexs.begin();
sal_Int32 nIndex = 0;
bool bFound = false;
for( ; ii != m_vFastPropertyIndexs.end(); ++ii,++nIndex )
{
if ( nHandle == (*ii))
{
bFound = true;
break;
}
}
if (!bFound)
{
nIndex = -1;
}
return nIndex;
}
#endif
/*
* public methods
*/
void XSecController::setFactory( const cssu::Reference<cssl::XMultiServiceFactory>& rxMSF)
/****** XSecController/setFactory *********************************************
*
* NAME
* setFactory -- configures the service factory component.
*
* SYNOPSIS
* setFactory( rxMSF );
*
* FUNCTION
* See NAME.
*
* INPUTS
* rxMSF - the service factory component
*
* RESULT
* empty
*
* HISTORY
* 05.01.2004 - implemented
*
* AUTHOR
* Michael Mi
* Email: michael.mi@sun.com
******************************************************************************/
{
mxMSF = rxMSF;
}
#if 0
void XSecController::setSignatureCreationResultListener(
const cssu::Reference< cssxc::sax::XSignatureCreationResultListener >& xSignatureCreationResultListener)
{
m_xSignatureCreationResultListener = xSignatureCreationResultListener;
}
void XSecController::setSignatureVerifyResultListener(
const cssu::Reference< cssxc::sax::XSignatureVerifyResultListener >& xSignatureVerifyResultListener)
{
m_xSignatureVerifyResultListener = xSignatureVerifyResultListener;
}
#endif
sal_Int32 XSecController::getNewSecurityId( )
{
sal_Int32 nId = m_nNextSecurityId;
m_nNextSecurityId++;
return nId;
}
void XSecController::startMission(
const cssu::Reference< cssxc::XUriBinding >& xUriBinding,
const cssu::Reference< cssxc::XXMLSecurityContext >& xSecurityContext )
/****** XSecController/startMission *******************************************
*
* NAME
* startMission -- starts a new security mission.
*
* SYNOPSIS
* startMission( xUriBinding, xSecurityContect );
*
* FUNCTION
* get ready for a new mission.
*
* INPUTS
* xUriBinding - the Uri binding that provide maps between uris and
* XInputStreams
* xSecurityContext - the security context component which can provide
* cryptoken
*
* RESULT
* empty
*
* HISTORY
* 05.01.2004 - implemented
*
* AUTHOR
* Michael Mi
* Email: michael.mi@sun.com
******************************************************************************/
{
m_xUriBinding = xUriBinding;
m_nStatusOfSecurityComponents = UNINITIALIZED;
m_xSecurityContext = xSecurityContext;
m_pErrorMessage = NULL;
m_vInternalSignatureInformations.clear();
m_bVerifyCurrentSignature = false;
}
void XSecController::setSAXChainConnector(
const cssu::Reference< cssl::XInitialization >& xInitialization,
const cssu::Reference< cssxs::XDocumentHandler >& xDocumentHandler,
const cssu::Reference< cssxc::sax::XElementStackKeeper >& xElementStackKeeper)
/****** XSecController/setSAXChainConnector ***********************************
*
* NAME
* setSAXChainConnector -- configures the components which will
* collaborate with the SAXEventKeeper on the SAX chain.
*
* SYNOPSIS
* setSAXChainConnector( xInitialization,
* xDocumentHandler,
* xElementStackKeeper );
*
* FUNCTION
* See NAME.
*
* INPUTS
* xInitialization - the previous node on the SAX chain
* xDocumentHandler - the next node on the SAX chain
* xElementStackKeeper - the ElementStackKeeper component which reserves
* missed key SAX events for the SAXEventKeeper
*
* RESULT
* empty
*
* HISTORY
* 05.01.2004 - implemented
*
* AUTHOR
* Michael Mi
* Email: michael.mi@sun.com
******************************************************************************/
{
m_bIsPreviousNodeInitializable = true;
m_xPreviousNodeOnSAXChain = xInitialization;
m_xNextNodeOnSAXChain = xDocumentHandler;
m_xElementStackKeeper = xElementStackKeeper;
initializeSAXChain( );
}
void XSecController::setSAXChainConnector(
const cssu::Reference< cssxs::XParser >& xParser,
const cssu::Reference< cssxs::XDocumentHandler >& xDocumentHandler,
const cssu::Reference< cssxc::sax::XElementStackKeeper >& xElementStackKeeper)
/****** XSecController/setSAXChainConnector ***********************************
*
* NAME
* setSAXChainConnector -- configures the components which will
* collaborate with the SAXEventKeeper on the SAX chain.
*
* SYNOPSIS
* setSAXChainConnector( xParser, xDocumentHandler, xElementStackKeeper );
*
* FUNCTION
* See NAME.
*
* INPUTS
* xParser - the previous node on the SAX chain
* xDocumentHandler - the next node on the SAX chain
* xElementStackKeeper -the ElementStackKeeper component which reserves
* missed key SAX events for the SAXEventKeeper
*
* RESULT
* empty
*
* HISTORY
* 05.01.2004 - implemented
*
* AUTHOR
* Michael Mi
* Email: michael.mi@sun.com
******************************************************************************/
{
m_bIsPreviousNodeInitializable = false;
m_xPreviousNodeOnSAXChain = xParser;
m_xNextNodeOnSAXChain = xDocumentHandler;
m_xElementStackKeeper = xElementStackKeeper;
initializeSAXChain( );
}
void XSecController::clearSAXChainConnector()
/****** XSecController/clearSAXChainConnector *********************************
*
* NAME
* clearSAXChainConnector -- resets the collaborating components.
*
* SYNOPSIS
* clearSAXChainConnector( );
*
* FUNCTION
* See NAME.
*
* INPUTS
* empty
*
* RESULT
* empty
*
* HISTORY
* 05.01.2004 - implemented
*
* AUTHOR
* Michael Mi
* Email: michael.mi@sun.com
******************************************************************************/
{
/*
* before reseting, if the ElementStackKeeper has kept something, then
* those kept key SAX events must be transferred to the SAXEventKeeper
* first. This is to promise the next node to the SAXEventKeeper on the
* SAX chain always receives a complete document.
*/
if (m_xElementStackKeeper.is() && m_xSAXEventKeeper.is())
{
cssu::Reference< cssxs::XDocumentHandler > xSEKHandler(m_xSAXEventKeeper, cssu::UNO_QUERY);
m_xElementStackKeeper->retrieve(xSEKHandler, sal_True);
}
chainOff();
m_xPreviousNodeOnSAXChain = NULL;
m_xNextNodeOnSAXChain = NULL;
m_xElementStackKeeper = NULL;
}
void XSecController::endMission()
/****** XSecController/endMission *********************************************
*
* NAME
* endMission -- forces to end all missions
*
* SYNOPSIS
* endMission( );
*
* FUNCTION
* Deletes all signature information and forces all missions to an end.
*
* INPUTS
* empty
*
* RESULT
* empty
*
* HISTORY
* 05.01.2004 - implemented
*
* AUTHOR
* Michael Mi
* Email: michael.mi@sun.com
******************************************************************************/
{
sal_Int32 size = m_vInternalSignatureInformations.size();
for (int i=0; i<size; ++i)
{
if ( m_nStatusOfSecurityComponents == INITIALIZED )
/*
* ResolvedListener only exist when the security components are created.
*/
{
cssu::Reference< cssxc::sax::XMissionTaker > xMissionTaker
( m_vInternalSignatureInformations[i].xReferenceResolvedListener, cssu::UNO_QUERY );
/*
* askes the SignatureCreator/SignatureVerifier to release
* all resouces it uses.
*/
xMissionTaker->endMission();
}
}
m_xUriBinding = NULL;
m_xSecurityContext = NULL;
/*
* free the status change listener reference to this object
*/
if (m_xSAXEventKeeper.is())
{
cssu::Reference<cssxc::sax::XSAXEventKeeperStatusChangeBroadcaster>
xSAXEventKeeperStatusChangeBroadcaster(m_xSAXEventKeeper, cssu::UNO_QUERY);
xSAXEventKeeperStatusChangeBroadcaster
->addXSAXEventKeeperStatusChangeListener( NULL );
}
}
const char* XSecController::getErrorMessage()
/****** XSecController/getErrorMessage ****************************************
*
* NAME
* getErrorMessage -- get the last error message
*
* SYNOPSIS
* pErrorMessage = getErrorMessage( );
*
* FUNCTION
* see NAME.
*
* INPUTS
* empty
*
* RESULT
* empty
*
* HISTORY
* 22.04.2004 - implemented
*
* AUTHOR
* Michael Mi
* Email: michael.mi@sun.com
******************************************************************************/
{
return m_pErrorMessage;
}
void XSecController::exportSignature(
const cssu::Reference<cssxs::XDocumentHandler>& xDocumentHandler,
const SignatureInformation& signatureInfo )
/****** XSecController/exportSignature ****************************************
*
* NAME
* exportSignature -- export a signature structure to an XDocumentHandler
*
* SYNOPSIS
* exportSignature( xDocumentHandler, signatureInfo);
*
* FUNCTION
* see NAME.
*
* INPUTS
* xDocumentHandler - the document handler to receive the signature
* signatureInfo - signature to be exported
*
* RESULT
* empty
*
* HISTORY
* 26.05.2004 - implemented
*
* AUTHOR
* Michael Mi
* Email: michael.mi@sun.com
******************************************************************************/
{
/*
* defines all element tags in Signature element.
*/
rtl::OUString tag_Signature(RTL_CONSTASCII_USTRINGPARAM(TAG_SIGNATURE));
rtl::OUString tag_SignedInfo(RTL_CONSTASCII_USTRINGPARAM(TAG_SIGNEDINFO));
rtl::OUString tag_CanonicalizationMethod(RTL_CONSTASCII_USTRINGPARAM(TAG_CANONICALIZATIONMETHOD));
rtl::OUString tag_SignatureMethod(RTL_CONSTASCII_USTRINGPARAM(TAG_SIGNATUREMETHOD));
rtl::OUString tag_Reference(RTL_CONSTASCII_USTRINGPARAM(TAG_REFERENCE));
rtl::OUString tag_Transforms(RTL_CONSTASCII_USTRINGPARAM(TAG_TRANSFORMS));
rtl::OUString tag_Transform(RTL_CONSTASCII_USTRINGPARAM(TAG_TRANSFORM));
rtl::OUString tag_DigestMethod(RTL_CONSTASCII_USTRINGPARAM(TAG_DIGESTMETHOD));
rtl::OUString tag_DigestValue(RTL_CONSTASCII_USTRINGPARAM(TAG_DIGESTVALUE));
rtl::OUString tag_SignatureValue(RTL_CONSTASCII_USTRINGPARAM(TAG_SIGNATUREVALUE));
rtl::OUString tag_KeyInfo(RTL_CONSTASCII_USTRINGPARAM(TAG_KEYINFO));
rtl::OUString tag_X509Data(RTL_CONSTASCII_USTRINGPARAM(TAG_X509DATA));
rtl::OUString tag_X509IssuerSerial(RTL_CONSTASCII_USTRINGPARAM(TAG_X509ISSUERSERIAL));
rtl::OUString tag_X509IssuerName(RTL_CONSTASCII_USTRINGPARAM(TAG_X509ISSUERNAME));
rtl::OUString tag_X509SerialNumber(RTL_CONSTASCII_USTRINGPARAM(TAG_X509SERIALNUMBER));
rtl::OUString tag_X509Certificate(RTL_CONSTASCII_USTRINGPARAM(TAG_X509CERTIFICATE));
rtl::OUString tag_Object(RTL_CONSTASCII_USTRINGPARAM(TAG_OBJECT));
rtl::OUString tag_SignatureProperties(RTL_CONSTASCII_USTRINGPARAM(TAG_SIGNATUREPROPERTIES));
rtl::OUString tag_SignatureProperty(RTL_CONSTASCII_USTRINGPARAM(TAG_SIGNATUREPROPERTY));
rtl::OUString tag_Timestamp(RTL_CONSTASCII_USTRINGPARAM(TAG_TIMESTAMP));
rtl::OUString tag_Date(RTL_CONSTASCII_USTRINGPARAM(TAG_DATE));
rtl::OUString tag_Time(RTL_CONSTASCII_USTRINGPARAM(TAG_TIME));
const SignatureReferenceInformations& vReferenceInfors = signatureInfo.vSignatureReferenceInfors;
SvXMLAttributeList *pAttributeList;
/*
* Write Signature element
*/
pAttributeList = new SvXMLAttributeList();
pAttributeList->AddAttribute(
rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(ATTR_XMLNS)),
rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(NS_XMLDSIG)));
if (signatureInfo.ouSignatureId.getLength()>0)
{
pAttributeList->AddAttribute(
rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(ATTR_ID)),
rtl::OUString(signatureInfo.ouSignatureId));
}
xDocumentHandler->startElement( tag_Signature, cssu::Reference< cssxs::XAttributeList > (pAttributeList));
{
/* Write SignedInfo element */
xDocumentHandler->startElement(
tag_SignedInfo,
cssu::Reference< cssxs::XAttributeList > (new SvXMLAttributeList()));
{
/* Write CanonicalizationMethod element */
pAttributeList = new SvXMLAttributeList();
pAttributeList->AddAttribute(
rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(ATTR_ALGORITHM)),
rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(ALGO_C14N)));
xDocumentHandler->startElement( tag_CanonicalizationMethod, cssu::Reference< cssxs::XAttributeList > (pAttributeList) );
xDocumentHandler->endElement( tag_CanonicalizationMethod );
/* Write SignatureMethod element */
pAttributeList = new SvXMLAttributeList();
pAttributeList->AddAttribute(
rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(ATTR_ALGORITHM)),
rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(ALGO_RSASHA1)));
xDocumentHandler->startElement( tag_SignatureMethod, cssu::Reference< cssxs::XAttributeList > (pAttributeList) );
xDocumentHandler->endElement( tag_SignatureMethod );
/* Write Reference element */
int j;
int refNum = vReferenceInfors.size();
for(j=0; j<refNum; ++j)
{
const SignatureReferenceInformation& refInfor = vReferenceInfors[j];
pAttributeList = new SvXMLAttributeList();
if ( refInfor.nType != 1 )
/*
* stream reference
*/
{
pAttributeList->AddAttribute(
rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(ATTR_URI)),
refInfor.ouURI);
}
else
/*
* same-document reference
*/
{
pAttributeList->AddAttribute(
rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(ATTR_URI)),
rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(CHAR_FRAGMENT))+refInfor.ouURI);
}
xDocumentHandler->startElement( tag_Reference, cssu::Reference< cssxs::XAttributeList > (pAttributeList) );
{
/* Write Transforms element */
if (refInfor.nType == 3)
/*
* xml stream, so c14n transform is needed
*/
{
xDocumentHandler->startElement(
tag_Transforms,
cssu::Reference< cssxs::XAttributeList > (new SvXMLAttributeList()));
{
pAttributeList = new SvXMLAttributeList();
pAttributeList->AddAttribute(
rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(ATTR_ALGORITHM)),
rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(ALGO_C14N)));
xDocumentHandler->startElement(
tag_Transform,
cssu::Reference< cssxs::XAttributeList > (pAttributeList) );
xDocumentHandler->endElement( tag_Transform );
}
xDocumentHandler->endElement( tag_Transforms );
}
/* Write DigestMethod element */
pAttributeList = new SvXMLAttributeList();
pAttributeList->AddAttribute(
rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(ATTR_ALGORITHM)),
rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(ALGO_XMLDSIGSHA1)));
xDocumentHandler->startElement(
tag_DigestMethod,
cssu::Reference< cssxs::XAttributeList > (pAttributeList) );
xDocumentHandler->endElement( tag_DigestMethod );
/* Write DigestValue element */
xDocumentHandler->startElement(
tag_DigestValue,
cssu::Reference< cssxs::XAttributeList > (new SvXMLAttributeList()));
xDocumentHandler->characters( refInfor.ouDigestValue );
xDocumentHandler->endElement( tag_DigestValue );
}
xDocumentHandler->endElement( tag_Reference );
}
}
xDocumentHandler->endElement( tag_SignedInfo );
/* Write SignatureValue element */
xDocumentHandler->startElement(
tag_SignatureValue,
cssu::Reference< cssxs::XAttributeList > (new SvXMLAttributeList()));
xDocumentHandler->characters( signatureInfo.ouSignatureValue );
xDocumentHandler->endElement( tag_SignatureValue );
/* Write KeyInfo element */
xDocumentHandler->startElement(
tag_KeyInfo,
cssu::Reference< cssxs::XAttributeList > (new SvXMLAttributeList()));
{
/* Write X509Data element */
xDocumentHandler->startElement(
tag_X509Data,
cssu::Reference< cssxs::XAttributeList > (new SvXMLAttributeList()));
{
/* Write X509IssuerSerial element */
xDocumentHandler->startElement(
tag_X509IssuerSerial,
cssu::Reference< cssxs::XAttributeList > (new SvXMLAttributeList()));
{
/* Write X509IssuerName element */
xDocumentHandler->startElement(
tag_X509IssuerName,
cssu::Reference< cssxs::XAttributeList > (new SvXMLAttributeList()));
xDocumentHandler->characters( signatureInfo.ouX509IssuerName );
xDocumentHandler->endElement( tag_X509IssuerName );
/* Write X509SerialNumber element */
xDocumentHandler->startElement(
tag_X509SerialNumber,
cssu::Reference< cssxs::XAttributeList > (new SvXMLAttributeList()));
xDocumentHandler->characters( signatureInfo.ouX509SerialNumber );
xDocumentHandler->endElement( tag_X509SerialNumber );
}
xDocumentHandler->endElement( tag_X509IssuerSerial );
/* Write X509Certificate element */
if (signatureInfo.ouX509Certificate.getLength()>0)
{
xDocumentHandler->startElement(
tag_X509Certificate,
cssu::Reference< cssxs::XAttributeList > (new SvXMLAttributeList()));
xDocumentHandler->characters( signatureInfo.ouX509Certificate );
xDocumentHandler->endElement( tag_X509Certificate );
}
}
xDocumentHandler->endElement( tag_X509Data );
}
xDocumentHandler->endElement( tag_KeyInfo );
if (signatureInfo.ouDate.getLength()>0 ||signatureInfo.ouTime.getLength()>0)
{
/* Write Object element */
xDocumentHandler->startElement(
tag_Object,
cssu::Reference< cssxs::XAttributeList > (new SvXMLAttributeList()));
{
/* Write SignatureProperties element */
xDocumentHandler->startElement(
tag_SignatureProperties,
cssu::Reference< cssxs::XAttributeList > (new SvXMLAttributeList()));
{
/* Write SignatureProperty element */
pAttributeList = new SvXMLAttributeList();
pAttributeList->AddAttribute(
rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(ATTR_ID)),
signatureInfo.ouPropertyId);
pAttributeList->AddAttribute(
rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(ATTR_TARGET)),
rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(CHAR_FRAGMENT))+signatureInfo.ouSignatureId);
xDocumentHandler->startElement(
tag_SignatureProperty,
cssu::Reference< cssxs::XAttributeList > (pAttributeList));
{
/* Write timestamp element */
pAttributeList = new SvXMLAttributeList();
pAttributeList->AddAttribute(
rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(ATTR_XMLNS)),
rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(NS_DATETIME)));
xDocumentHandler->startElement(
tag_Timestamp,
cssu::Reference< cssxs::XAttributeList > (pAttributeList));
{
/* Write date element */
xDocumentHandler->startElement(
tag_Date,
cssu::Reference< cssxs::XAttributeList > (new SvXMLAttributeList()));
xDocumentHandler->characters( signatureInfo.ouDate );
xDocumentHandler->endElement( tag_Date );
/* Write time element */
xDocumentHandler->startElement(
tag_Time,
cssu::Reference< cssxs::XAttributeList > (new SvXMLAttributeList()));
xDocumentHandler->characters( signatureInfo.ouTime );
xDocumentHandler->endElement( tag_Time );
}
xDocumentHandler->endElement( tag_Timestamp );
}
xDocumentHandler->endElement( tag_SignatureProperty );
}
xDocumentHandler->endElement( tag_SignatureProperties );
}
xDocumentHandler->endElement( tag_Object );
}
}
xDocumentHandler->endElement( tag_Signature );
}
bool XSecController::getSignatureInfor( sal_Int32 nSecurityId, SignatureInformation& signatureInfor )
{
int index = findSignatureInfor(nSecurityId);
if (index == -1)
{
return false;
}
else
{
signatureInfor = m_vInternalSignatureInformations[index].signatureInfor;
return true;
}
}
SignatureInformations XSecController::getSignatureInformations()
{
SignatureInformations vInfors;
int sigNum = m_vInternalSignatureInformations.size();
for (int i=0; i<sigNum; ++i)
{
SignatureInformation si = m_vInternalSignatureInformations[i].signatureInfor;
vInfors.push_back(si);
}
return vInfors;
}
/*
* XSecurityController
*
* no methods
*/
/*
* XFastPropertySet
*/
/*
void SAL_CALL XSecController::setFastPropertyValue(
sal_Int32 nHandle,
const cssu::Any& aValue )
throw ( cssb::UnknownPropertyException,
cssb::PropertyVetoException,
cssl::IllegalArgumentException,
cssl::WrappedTargetException,
cssu::RuntimeException)
{
sal_Int32 nIndex = getFastPropertyIndex(nHandle);
if (nIndex == -1)
{
m_vFastPropertyIndexs.push_back( nHandle );
m_vFastPropertyValues.push_back( aValue );
}
else
{
m_vFastPropertyValues[nIndex] = aValue;
}
}
cssu::Any SAL_CALL XSecController::getFastPropertyValue(
sal_Int32 nHandle )
throw (
cssb::UnknownPropertyException,
cssl::WrappedTargetException,
cssu::RuntimeException)
{
cssu::Any aValue;
sal_Int32 nIndex = getFastPropertyIndex(nHandle);
if (nIndex != -1)
{
aValue = m_vFastPropertyValues[nIndex];
}
return aValue;
}
*/
/*
* XSAXEventKeeperStatusChangeListener
*/
void SAL_CALL XSecController::blockingStatusChanged( sal_Bool isBlocking )
throw (cssu::RuntimeException)
{
/*
showMessageBox( rtl::OUString::createFromAscii((isBlocking?
"Blocking Status => TRUE":
"Blocking Status => FALSE")),
rtl::OUString::createFromAscii("SAXEventKeeper Status"));
*/
this->m_bIsBlocking = isBlocking;
checkChainingStatus();
}
void SAL_CALL XSecController::collectionStatusChanged(
sal_Bool isInsideCollectedElement )
throw (cssu::RuntimeException)
{
/*
showMessageBox( rtl::OUString::createFromAscii((isInsideCollectedElement?
"Collection Status => TRUE":
"Collection Status => FALSE")),
rtl::OUString::createFromAscii("SAXEventKeeper Status"));
*/
this->m_bIsCollectingElement = isInsideCollectedElement;
checkChainingStatus();
}
void SAL_CALL XSecController::bufferStatusChanged( sal_Bool isBufferEmpty )
throw (cssu::RuntimeException)
{
/*
showMessageBox( rtl::OUString::createFromAscii((isBufferEmpty?
"Buffer Empty => TRUE":
"Buffer Empty => FALSE")),
rtl::OUString::createFromAscii("SAXEventKeeper Status"));
*/
}
/*
* XSignatureCreationResultListener
*/
void SAL_CALL XSecController::signatureCreated( sal_Int32 securityId, com::sun::star::xml::crypto::sax::SignatureCreationResult nResult )
throw (com::sun::star::uno::RuntimeException)
{
int index = findSignatureInfor(securityId);
DBG_ASSERT( index != -1, "Signature Not Found!" );
SignatureInformation& signatureInfor = m_vInternalSignatureInformations[index].signatureInfor;
if (nResult == cssxc::sax::SignatureCreationResult_CREATIONSUCCEED)
{
signatureInfor.nStatus = STATUS_CREATION_SUCCEED;
}
else
{
signatureInfor.nStatus = STATUS_CREATION_FAIL;
}
}
/*
* XSignatureVerifyResultListener
*/
void SAL_CALL XSecController::signatureVerified( sal_Int32 securityId, com::sun::star::xml::crypto::sax::SignatureVerifyResult nResult )
throw (com::sun::star::uno::RuntimeException)
{
int index = findSignatureInfor(securityId);
DBG_ASSERT( index != -1, "Signature Not Found!" );
SignatureInformation& signatureInfor = m_vInternalSignatureInformations[index].signatureInfor;
if (nResult == cssxc::sax::SignatureVerifyResult_VERIFYSUCCEED)
{
signatureInfor.nStatus = STATUS_VERIFY_SUCCEED;
}
else
{
signatureInfor.nStatus = STATUS_VERIFY_FAIL;
}
}
Reference in New Issue Copy Permalink