| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_xmlsecurity.hxx" |
| |
| #include <xsecctl.hxx> |
| #include <tools/debug.hxx> |
| |
| #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/SecurityOperationStatus.hpp> |
| |
| #include <xmloff/attrlist.hxx> |
| #include <rtl/math.hxx> |
| #include <tools/string.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; |
| |
| const sal_Int8 XML_MAXDIGITSCOUNT_TIME = 11; |
| const sal_Int8 XML_MAXDIGITSCOUNT_DATETIME = 6; |
| |
| /* 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( const cssu::Reference<cssu::XComponentContext>& rxCtx ) |
| :mxCtx(rxCtx), |
| m_nNextSecurityId(1), |
| m_bIsSAXEventKeeperConnected(false), |
| m_nStatusOfSecurityComponents(UNINITIALIZED), |
| m_bIsSAXEventKeeperSticky(false), |
| m_pErrorMessage(NULL), |
| m_pXSecParser(NULL) |
| { |
| } |
| |
| XSecController::~XSecController() |
| { |
| } |
| |
| |
| /* |
| * private methods |
| */ |
| /** convert string to number with optional min and max values */ |
| sal_Bool XSecController::convertNumber( sal_Int32& rValue, |
| const rtl::OUString& rString, |
| sal_Int32 /*nMin*/, sal_Int32 /*nMax*/ ) |
| { |
| sal_Bool bNeg = sal_False; |
| rValue = 0; |
| |
| sal_Int32 nPos = 0L; |
| sal_Int32 nLen = rString.getLength(); |
| |
| // skip white space |
| while( nPos < nLen && sal_Unicode(' ') == rString[nPos] ) |
| nPos++; |
| |
| if( nPos < nLen && sal_Unicode('-') == rString[nPos] ) |
| { |
| bNeg = sal_True; |
| nPos++; |
| } |
| |
| // get number |
| while( nPos < nLen && |
| sal_Unicode('0') <= rString[nPos] && |
| sal_Unicode('9') >= rString[nPos] ) |
| { |
| // TODO: check overflow! |
| rValue *= 10; |
| rValue += (rString[nPos] - sal_Unicode('0')); |
| nPos++; |
| } |
| |
| if( bNeg ) |
| rValue *= -1; |
| |
| return nPos == nLen; |
| } |
| |
| /** convert util::DateTime to ISO Date String */ |
| void XSecController::convertDateTime( ::rtl::OUStringBuffer& rBuffer, |
| const com::sun::star::util::DateTime& rDateTime ) |
| { |
| String aString( String::CreateFromInt32( rDateTime.Year ) ); |
| aString += '-'; |
| if( rDateTime.Month < 10 ) |
| aString += '0'; |
| aString += String::CreateFromInt32( rDateTime.Month ); |
| aString += '-'; |
| if( rDateTime.Day < 10 ) |
| aString += '0'; |
| aString += String::CreateFromInt32( rDateTime.Day ); |
| |
| if( rDateTime.Seconds != 0 || |
| rDateTime.Minutes != 0 || |
| rDateTime.Hours != 0 ) |
| { |
| aString += 'T'; |
| if( rDateTime.Hours < 10 ) |
| aString += '0'; |
| aString += String::CreateFromInt32( rDateTime.Hours ); |
| aString += ':'; |
| if( rDateTime.Minutes < 10 ) |
| aString += '0'; |
| aString += String::CreateFromInt32( rDateTime.Minutes ); |
| aString += ':'; |
| if( rDateTime.Seconds < 10 ) |
| aString += '0'; |
| aString += String::CreateFromInt32( rDateTime.Seconds ); |
| if ( rDateTime.HundredthSeconds > 0) |
| { |
| aString += ','; |
| if (rDateTime.HundredthSeconds < 10) |
| aString += '0'; |
| aString += String::CreateFromInt32( rDateTime.HundredthSeconds ); |
| } |
| } |
| |
| rBuffer.append( aString ); |
| } |
| |
| /** convert ISO Date String to util::DateTime */ |
| sal_Bool XSecController::convertDateTime( com::sun::star::util::DateTime& rDateTime, |
| const ::rtl::OUString& rString ) |
| { |
| sal_Bool bSuccess = sal_True; |
| |
| rtl::OUString aDateStr, aTimeStr, sHundredth; |
| sal_Int32 nPos = rString.indexOf( (sal_Unicode) 'T' ); |
| sal_Int32 nPos2 = rString.indexOf( (sal_Unicode) ',' ); |
| if ( nPos >= 0 ) |
| { |
| aDateStr = rString.copy( 0, nPos ); |
| if ( nPos2 >= 0 ) |
| { |
| aTimeStr = rString.copy( nPos + 1, nPos2 - nPos - 1 ); |
| |
| //Get the fraction of a second with the accuracy of one hundreds second. |
| //The fraction part of the date could have different accuracies. To calculate |
| //the count of a hundredth units one could form a fractional number by appending |
| //the value of the time string to 0. Then multiply it by 100 and use only the whole number. |
| //For example: 5:27:46,1 -> 0,1 * 100 = 10 |
| //5:27:46,01 -> 0,01 * 100 = 1 |
| //5:27:46,001 -> 0,001 * 100 = 0 |
| //Due to the inaccuracy of floating point numbers the result may not be the same on different |
| //platforms. We had the case where we had a value of 24 hundredth of second, which converted to |
| //23 on Linux and 24 on Solaris and Windows. |
| |
| //we only support a hundredth second |
| //make ,1 -> 10 ,01 -> 1 ,001 -> only use first two diggits |
| sHundredth = rString.copy(nPos2 + 1); |
| sal_Int32 len = sHundredth.getLength(); |
| if (len == 1) |
| sHundredth += rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("0")); |
| if (len > 2) |
| sHundredth = sHundredth.copy(0, 2); |
| } |
| else |
| { |
| aTimeStr = rString.copy(nPos + 1); |
| sHundredth = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("0")); |
| } |
| } |
| else |
| aDateStr = rString; // no separator: only date part |
| |
| sal_Int32 nYear = 1899; |
| sal_Int32 nMonth = 12; |
| sal_Int32 nDay = 30; |
| sal_Int32 nHour = 0; |
| sal_Int32 nMin = 0; |
| sal_Int32 nSec = 0; |
| |
| const sal_Unicode* pStr = aDateStr.getStr(); |
| sal_Int32 nDateTokens = 1; |
| while ( *pStr ) |
| { |
| if ( *pStr == '-' ) |
| nDateTokens++; |
| pStr++; |
| } |
| if ( nDateTokens > 3 || aDateStr.getLength() == 0 ) |
| bSuccess = sal_False; |
| else |
| { |
| sal_Int32 n = 0; |
| if ( !convertNumber( nYear, aDateStr.getToken( 0, '-', n ), 0, 9999 ) ) |
| bSuccess = sal_False; |
| if ( nDateTokens >= 2 ) |
| if ( !convertNumber( nMonth, aDateStr.getToken( 0, '-', n ), 0, 12 ) ) |
| bSuccess = sal_False; |
| if ( nDateTokens >= 3 ) |
| if ( !convertNumber( nDay, aDateStr.getToken( 0, '-', n ), 0, 31 ) ) |
| bSuccess = sal_False; |
| } |
| |
| if ( aTimeStr.getLength() > 0 ) // time is optional |
| { |
| pStr = aTimeStr.getStr(); |
| sal_Int32 nTimeTokens = 1; |
| while ( *pStr ) |
| { |
| if ( *pStr == ':' ) |
| nTimeTokens++; |
| pStr++; |
| } |
| if ( nTimeTokens > 3 ) |
| bSuccess = sal_False; |
| else |
| { |
| sal_Int32 n = 0; |
| if ( !convertNumber( nHour, aTimeStr.getToken( 0, ':', n ), 0, 23 ) ) |
| bSuccess = sal_False; |
| if ( nTimeTokens >= 2 ) |
| if ( !convertNumber( nMin, aTimeStr.getToken( 0, ':', n ), 0, 59 ) ) |
| bSuccess = sal_False; |
| if ( nTimeTokens >= 3 ) |
| if ( !convertNumber( nSec, aTimeStr.getToken( 0, ':', n ), 0, 59 ) ) |
| bSuccess = sal_False; |
| } |
| } |
| |
| if (bSuccess) |
| { |
| rDateTime.Year = (sal_uInt16)nYear; |
| rDateTime.Month = (sal_uInt16)nMonth; |
| rDateTime.Day = (sal_uInt16)nDay; |
| rDateTime.Hours = (sal_uInt16)nHour; |
| rDateTime.Minutes = (sal_uInt16)nMin; |
| rDateTime.Seconds = (sal_uInt16)nSec; |
| // rDateTime.HundredthSeconds = sDoubleStr.toDouble() * 100; |
| rDateTime.HundredthSeconds = static_cast<sal_uInt16>(sHundredth.toInt32()); |
| } |
| return bSuccess; |
| } |
| |
| int XSecController::findSignatureInfor( sal_Int32 nSecurityId) const |
| /****** 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; |
| |
| cssu::Reference< cssl::XMultiComponentFactory > xMCF( mxCtx->getServiceManager() ); |
| |
| m_xXMLSignature = cssu::Reference< cssxc::XXMLSignature >( |
| xMCF->createInstanceWithContext( sXMLSignature, mxCtx ), |
| cssu::UNO_QUERY ); |
| |
| bool bSuccess = (0!=m_xXMLSignature.is()); |
| if ( bSuccess ) |
| /* |
| * XMLSignature created successfully. |
| */ |
| { |
| m_xXMLDocumentWrapper = cssu::Reference< cssxw::XXMLDocumentWrapper >( |
| xMCF->createInstanceWithContext( sXMLDocument, mxCtx ), |
| cssu::UNO_QUERY ); |
| } |
| |
| bSuccess &= (0!=m_xXMLDocumentWrapper.is()); |
| if ( bSuccess ) |
| /* |
| * XMLDocumentWrapper created successfully. |
| */ |
| { |
| m_xSAXEventKeeper = cssu::Reference< cssxc::sax::XSecuritySAXEventKeeper >( |
| xMCF->createInstanceWithContext( sSAXEventKeeper, mxCtx ), |
| 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 |
| ->addSAXEventKeeperStatusChangeListener( 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 |
| */ |
| |
| 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 |
| ->addSAXEventKeeperStatusChangeListener( 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_Date(RTL_CONSTASCII_USTRINGPARAM(TAG_DATE)); |
| #if 0 |
| 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)); |
| #endif |
| |
| 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 != TYPE_SAMEDOCUMENT_REFERENCE ) |
| /* |
| * 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 == TYPE_XMLSTREAM_REFERENCE) |
| /* |
| * 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 ); |
| |
| /* 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(":")) |
| +rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(NSTAG_DC)), |
| rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(NS_DC))); |
| |
| xDocumentHandler->startElement( |
| rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(NSTAG_DC)) |
| +rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(":")) |
| +tag_Date, |
| cssu::Reference< cssxs::XAttributeList > (pAttributeList)); |
| |
| ::rtl::OUStringBuffer buffer; |
| //If the xml signature was already contained in the document, |
| //then we use the original date and time string, rather then the |
| //converted one. When the original string is converted to the DateTime |
| //structure then information may be lost because it only holds a fractional |
| //of a second with a accuracy of one hundredth of second. If the string contains |
| //milli seconds (document was signed by an application other than OOo) |
| //and the converted time is written back, then the string looks different |
| //and the signature is broken. |
| if (signatureInfo.ouDateTime.getLength() > 0) |
| buffer = signatureInfo.ouDateTime; |
| else |
| convertDateTime( buffer, signatureInfo.stDateTime ); |
| xDocumentHandler->characters( buffer.makeStringAndClear() ); |
| |
| xDocumentHandler->endElement( |
| rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(NSTAG_DC)) |
| +rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(":")) |
| +tag_Date); |
| } |
| xDocumentHandler->endElement( tag_SignatureProperty ); |
| } |
| xDocumentHandler->endElement( tag_SignatureProperties ); |
| } |
| xDocumentHandler->endElement( tag_Object ); |
| } |
| xDocumentHandler->endElement( tag_Signature ); |
| } |
| |
| SignatureInformation XSecController::getSignatureInformation( sal_Int32 nSecurityId ) const |
| { |
| SignatureInformation aInf( 0 ); |
| int nIndex = findSignatureInfor(nSecurityId); |
| DBG_ASSERT( nIndex != -1, "getSignatureInformation - SecurityId is invalid!" ); |
| if ( nIndex != -1) |
| { |
| aInf = m_vInternalSignatureInformations[nIndex].signatureInfor; |
| } |
| return aInf; |
| } |
| |
| SignatureInformations XSecController::getSignatureInformations() const |
| { |
| 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::SecurityOperationStatus 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; |
| } |
| */ |
| signatureInfor.nStatus = nResult; |
| } |
| |
| /* |
| * XSignatureVerifyResultListener |
| */ |
| void SAL_CALL XSecController::signatureVerified( sal_Int32 securityId, com::sun::star::xml::crypto::SecurityOperationStatus 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; |
| } |
| */ |
| signatureInfor.nStatus = nResult; |
| } |