1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 24 // MARKER(update_precomp.py): autogen include statement, do not remove 25 #include "precompiled_xmlsecurity.hxx" 26 27 #include <stdio.h> 28 #include <string.h> 29 30 #include <rtl/ustring.hxx> 31 #include <cppuhelper/bootstrap.hxx> 32 #include <cppuhelper/servicefactory.hxx> 33 #include <com/sun/star/bridge/XUnoUrlResolver.hpp> 34 #include <com/sun/star/registry/XImplementationRegistration.hpp> 35 #include <com/sun/star/beans/XPropertySet.hpp> 36 #include <com/sun/star/lang/XMultiComponentFactory.hpp> 37 38 #include <comphelper/processfactory.hxx> 39 40 #include <iostream> 41 #include <fstream> 42 43 #include <util.hxx> 44 45 #include <com/sun/star/lang/XMultiServiceFactory.hpp> 46 #include <com/sun/star/io/XOutputStream.hpp> 47 #include <com/sun/star/io/XInputStream.hpp> 48 #include <com/sun/star/xml/sax/XParser.hpp> 49 #include <com/sun/star/xml/sax/XDocumentHandler.hpp> 50 #include <com/sun/star/xml/sax/XAttributeList.hpp> 51 #include <cppuhelper/implbase4.hxx> 52 53 #include <com/sun/star/xml/crypto/sax/XSignatureCreationResultListener.hpp> 54 #include <com/sun/star/xml/crypto/sax/XSignatureVerifyResultListener.hpp> 55 #include <com/sun/star/xml/crypto/sax/XSAXEventKeeperStatusChangeListener.hpp> 56 #include <com/sun/star/xml/crypto/sax/XSecuritySAXEventKeeper.hpp> 57 #include <com/sun/star/xml/crypto/sax/XReferenceResolvedListener.hpp> 58 #include <com/sun/star/xml/crypto/XXMLSignature.hpp> 59 #include <com/sun/star/xml/wrapper/XXMLDocumentWrapper.hpp> 60 #include <com/sun/star/xml/csax/XMLAttribute.hpp> 61 #include <com/sun/star/xml/crypto/XSEInitializer.hpp> 62 #include <com/sun/star/xml/crypto/SecurityOperationStatus.hpp> 63 #include <com/sun/star/io/XActiveDataSource.hpp> 64 #include <com/sun/star/lang/XInitialization.hpp> 65 #include <com/sun/star/xml/crypto/sax/XKeyCollector.hpp> 66 #include <com/sun/star/xml/crypto/sax/ElementMarkPriority.hpp> 67 #include <com/sun/star/xml/crypto/sax/XReferenceResolvedBroadcaster.hpp> 68 #include <com/sun/star/xml/crypto/sax/XMissionTaker.hpp> 69 #include <com/sun/star/xml/crypto/sax/XBlockerMonitor.hpp> 70 #include <com/sun/star/xml/crypto/sax/XSignatureCreationResultBroadcaster.hpp> 71 #include <com/sun/star/xml/crypto/sax/XSignatureVerifyResultBroadcaster.hpp> 72 #include <com/sun/star/xml/crypto/sax/XReferenceCollector.hpp> 73 #include <com/sun/star/xml/crypto/sax/XSAXEventKeeperStatusChangeBroadcaster.hpp> 74 #include <com/sun/star/xml/wrapper/XXMLDocumentWrapper.hpp> 75 76 #include <xmloff/attrlist.hxx> 77 78 //#include <malloc.h> 79 #include <stdio.h> 80 #include <stdlib.h> 81 #include <string.h> 82 83 /* 84 * Can not build under solaris. 85 * Delete the memory.h including by AF 86 #include <memory.h> 87 */ 88 89 #include <sys/types.h> 90 #include <sys/stat.h> 91 #include <osl/time.h> 92 93 94 95 #ifndef INCLUDED_VECTOR 96 #include <vector> 97 #define INCLUDED_VECTOR 98 #endif 99 100 #ifndef INCLUDED_STACK 101 #include <stack> 102 #define INCLUDED_STACK 103 #endif 104 105 /* xml security framework components */ 106 #define SIGNATURECREATOR_COMPONENT "com.sun.star.xml.crypto.sax.SignatureCreator" 107 #define SIGNATUREVERIFIER_COMPONENT "com.sun.star.xml.crypto.sax.SignatureVerifier" 108 #define JAVAFLATFILTER_COMPONENT "com.sun.star.xml.crypto.eval.JavaFlatFilter" 109 #define SAXEVENTKEEPER_COMPONENT "com.sun.star.xml.crypto.sax.SAXEventKeeper" 110 111 /* java based bridge components */ 112 #define SEINITIALIZER_JAVA_COMPONENT "com.sun.star.xml.security.bridge.jxsec.SEInitializer_JxsecImpl" 113 #define XMLSIGNATURE_JAVA_COMPONENT "com.sun.star.xml.security.bridge.jxsec.XMLSignature_JxsecImpl" 114 #define XMLDOCUMENTWRAPPER_JAVA_COMPONENT "com.sun.star.xml.security.bridge.jxsec.XMLDocumentWrapper_JxsecImpl" 115 116 /* c based bridge components */ 117 #define SEINITIALIZER_C_COMPONENT "com.sun.star.xml.crypto.SEInitializer" 118 #define XMLSIGNATURE_C_COMPONENT "com.sun.star.xml.crypto.XMLSignature" 119 #define XMLDOCUMENT_C_COMPONENT "com.sun.star.xml.wrapper.XMLDocumentWrapper" 120 121 /* security related elements and attributes */ 122 #define SIGNATURE_STR "Signature" 123 #define REFERENCE_STR "Reference" 124 #define SIGNEDINFO_STR "SignedInfo" 125 #define KEYINFO_STR "KeyInfo" 126 #define KEYVALUE_STR "KeyValue" 127 #define KEYNAME_STR "KeyName" 128 #define X509DATA_STR "X509Data" 129 #define ENCRYPTEDKEY_STR "EncryptedKey" 130 #define RETRIEVALMETHOD_STR "RetrievalMethod" 131 #define OTHER_ELEMENT_STR "OTHER_ELEMENT_STR" 132 #define REFNUM_ATTR_STR "refNum" 133 #define URI_ATTR_STR "URI" 134 135 136 #define RTL_ASCII_USTRINGPARAM( asciiStr ) asciiStr, strlen( asciiStr ), RTL_TEXTENCODING_ASCII_US 137 138 namespace cssu = com::sun::star::uno; 139 namespace cssl = com::sun::star::lang; 140 namespace cssb = com::sun::star::beans; 141 namespace cssi = com::sun::star::io; 142 namespace cssxc = com::sun::star::xml::crypto; 143 namespace cssxs = com::sun::star::xml::sax; 144 namespace cssxw = com::sun::star::xml::wrapper; 145 namespace cssxcsax = com::sun::star::xml::csax; 146 147 148 using namespace ::com::sun::star; 149 150 151 class XSecTester; 152 153 /* 154 * The XSecTester class is a C++ version of SecurityFramworkController.java 155 * 156 */ 157 158 class SecurityEntity 159 { 160 private: 161 static int m_nNextSecurityId; 162 rtl::OUString m_ouKeyURI; 163 164 protected: 165 com::sun::star::uno::Reference< 166 com::sun::star::lang::XMultiServiceFactory > mxMSF; 167 168 com::sun::star::uno::Reference< 169 com::sun::star::xml::crypto::sax::XReferenceResolvedListener > 170 m_xReferenceListener; 171 172 com::sun::star::uno::Reference< 173 com::sun::star::xml::crypto::sax::XSecuritySAXEventKeeper > 174 m_xSAXEventKeeper; 175 176 com::sun::star::uno::Reference< 177 com::sun::star::xml::crypto::XXMLSecurityContext > 178 m_xXMLSecurityContext; 179 180 com::sun::star::uno::Reference< 181 com::sun::star::xml::crypto::XXMLSignature > 182 m_xXMLSignature; 183 184 int m_nSecurityId; 185 186 private: 187 int getNextSecurityId() const; 188 189 protected: 190 SecurityEntity( 191 const com::sun::star::uno::Reference< 192 com::sun::star::xml::crypto::sax::XSecuritySAXEventKeeper >& 193 xSAXEventKeeper, 194 const com::sun::star::uno::Reference< 195 com::sun::star::xml::crypto::XXMLSecurityContext >& 196 xXMLSecurityContext, 197 const com::sun::star::uno::Reference< 198 com::sun::star::xml::crypto::XXMLSignature >& 199 xXMLSignature, 200 const com::sun::star::uno::Reference< 201 com::sun::star::lang::XMultiServiceFactory >& 202 rsMSF); 203 204 public: 205 void setKeyId(int nId); 206 207 int getSecurityId() const; 208 209 com::sun::star::uno::Reference< 210 com::sun::star::xml::crypto::sax::XReferenceResolvedListener > 211 getReferenceListener() const; 212 213 bool setKey( const rtl::OUString& ouUri, bool bIsExporting ); 214 215 void setKeyURI(const rtl::OUString& ouUri); 216 217 bool endMission(); 218 }; 219 220 221 class SignatureEntity : public SecurityEntity 222 { 223 private: 224 std::vector< rtl::OUString > m_vReferenceIds; 225 int m_nSignatureElementCollectorId; 226 227 bool hasReference(const rtl::OUString& ouUri) const; 228 229 public: 230 SignatureEntity( 231 const com::sun::star::uno::Reference< 232 com::sun::star::xml::crypto::sax::XSecuritySAXEventKeeper >& 233 xSAXEventKeeper, 234 bool bIsExporting, 235 XSecTester* pListener, 236 const com::sun::star::uno::Reference< 237 com::sun::star::xml::crypto::XXMLSecurityContext >& 238 xXMLSecurityContext, 239 const com::sun::star::uno::Reference< 240 com::sun::star::xml::crypto::XXMLSignature >& 241 xXMLSignature, 242 const com::sun::star::uno::Reference< 243 com::sun::star::lang::XMultiServiceFactory >& 244 rsMSF); 245 ~SignatureEntity(){}; 246 247 void setReferenceNumber() const; 248 bool setReference( const rtl::OUString& ouUri, bool bIsExporting ) const; 249 void addReferenceURI( const rtl::OUString& ouUri ); 250 }; 251 252 struct AncestorEvent 253 { 254 AncestorEvent( sal_Int32 nAttrNum ):aAttributeList(nAttrNum){}; 255 256 bool bIsStartElement; 257 rtl::OUString ouName; 258 259 com::sun::star::uno::Sequence< 260 com::sun::star::xml::csax::XMLAttribute > 261 aAttributeList; 262 }; 263 264 class XSecTester : public cppu::WeakImplHelper4 265 < 266 com::sun::star::xml::crypto::sax::XSignatureCreationResultListener, 267 com::sun::star::xml::crypto::sax::XSignatureVerifyResultListener, 268 com::sun::star::xml::crypto::sax::XSAXEventKeeperStatusChangeListener, 269 com::sun::star::xml::sax::XDocumentHandler 270 > 271 { 272 private: 273 com::sun::star::uno::Reference< com::sun::star::lang::XMultiServiceFactory > mxMSF; 274 275 sal_Int32 m_nTotalSignatureNumber; 276 sal_Int32 m_nSuccessfulSignatureNumber; 277 278 com::sun::star::uno::Reference< 279 com::sun::star::xml::sax::XDocumentHandler > 280 m_xExportHandler; 281 282 com::sun::star::uno::Reference< 283 com::sun::star::xml::crypto::sax::XSecuritySAXEventKeeper > 284 m_xSAXEventKeeper; 285 286 com::sun::star::uno::Reference< 287 com::sun::star::xml::wrapper::XXMLDocumentWrapper > 288 m_xXMLDocumentWrapper; 289 290 com::sun::star::uno::Reference< 291 com::sun::star::xml::sax::XDocumentHandler > 292 m_xOutputHandler; 293 294 com::sun::star::uno::Reference< 295 com::sun::star::xml::sax::XParser > 296 m_xSaxParser; 297 298 std::stack< void* > m_stCurrentPath; 299 std::stack< bool > m_stCurrentPathType; 300 301 std::vector< AncestorEvent* > m_vAncestorEvents; 302 std::vector< SignatureEntity* > m_vSignatureList; 303 304 std::vector< rtl::OUString > m_vUnsolvedReferenceURIs; 305 std::vector< int > m_vUnsolvedReferenceKeeperIds; 306 std::vector< int > m_vUnsolvedReferenceRefNums; 307 308 bool m_bIsExporting; 309 bool m_bIsBlocking; 310 311 bool m_bIsInsideCollectedElement; 312 bool m_bIsSAXEventKeeperOnTheSAXChain; 313 314 com::sun::star::uno::Reference< 315 com::sun::star::xml::crypto::XXMLSecurityContext > 316 m_xXMLSecurityContext; 317 318 com::sun::star::uno::Reference< 319 com::sun::star::xml::crypto::XXMLSignature > 320 m_xXMLSignature; 321 322 rtl::OUString m_ouJavaCryptokenDir; 323 rtl::OUString m_ouCCryptokenDir; 324 rtl::OUString m_ouXMLDocumentWrapperComponentName; 325 326 private: 327 com::sun::star::uno::Reference< 328 com::sun::star::io::XOutputStream > 329 createOutputStream( const rtl::OUString& ouFile ); 330 331 rtl::OUString parseFile( 332 const rtl::OUString& ouInputFileName, 333 const rtl::OUString& ouOutputFileName, 334 bool bIsExporting, 335 bool bIsJavaBased); 336 337 void changeOutput(); 338 339 bool foundSecurityRelated(); 340 341 void findKeyOrReference(SecurityEntity* pSecurityEntity, const rtl::OUString& ouUri, bool bIsFindKey); 342 343 bool checkSecurityElement( 344 const rtl::OUString& ouLocalName, 345 const com::sun::star::uno::Reference< 346 com::sun::star::xml::sax::XAttributeList>& xAttribs); 347 348 void checkReference( 349 const rtl::OUString& ouLocalName, 350 const com::sun::star::uno::Reference< 351 com::sun::star::xml::sax::XAttributeList>& xAttribs, 352 const rtl::OUString& ouId); 353 354 void endMission(); 355 356 void addStartAncestorEvent( 357 const rtl::OUString& ouName, 358 const com::sun::star::uno::Reference< 359 com::sun::star::xml::sax::XAttributeList>& xAttribs); 360 361 void addEndAncestorEvent( const rtl::OUString& ouName ); 362 363 void flushAncestorEvents( 364 const com::sun::star::uno::Reference< 365 com::sun::star::xml::sax::XDocumentHandler >& xDocumentHandler); 366 367 void XSecTester::sendAncestorStartElementEvent( 368 const rtl::OUString& ouName, 369 const com::sun::star::uno::Sequence< 370 com::sun::star::xml::csax::XMLAttribute >& xAttrList, 371 const com::sun::star::uno::Reference< 372 com::sun::star::xml::sax::XDocumentHandler >& xDocumentHandler) const; 373 374 void XSecTester::sendAncestorEndElementEvent( 375 const rtl::OUString& ouName, 376 const com::sun::star::uno::Reference< 377 com::sun::star::xml::sax::XDocumentHandler >& xDocumentHandler) const; 378 379 std::vector< AncestorEvent* >::const_iterator XSecTester::checkAncestorStartElementEvent( 380 const std::vector< AncestorEvent* >::const_iterator& ii, 381 const com::sun::star::uno::Reference< 382 com::sun::star::xml::sax::XDocumentHandler >& xDocumentHandler) const; 383 384 public: 385 XSecTester(const com::sun::star::uno::Reference< 386 com::sun::star::lang::XMultiServiceFactory >& rxMSF) 387 :mxMSF( rxMSF ){}; 388 virtual ~XSecTester(){}; 389 390 /* XSignatureCreationResultListener */ 391 virtual void SAL_CALL signatureCreated( 392 sal_Int32 securityId, 393 com::sun::star::xml::crypto::SecurityOperationStatus creationResult ) 394 throw (com::sun::star::uno::RuntimeException); 395 396 /* XSignatureVerifyResultListener */ 397 virtual void SAL_CALL signatureVerified( 398 sal_Int32 securityId, 399 com::sun::star::xml::crypto::SecurityOperationStatus verifyResult ) 400 throw (com::sun::star::uno::RuntimeException); 401 402 /* XSAXEventKeeperStatusChangeListener */ 403 virtual void SAL_CALL blockingStatusChanged( sal_Bool isBlocking ) 404 throw (com::sun::star::uno::RuntimeException); 405 virtual void SAL_CALL collectionStatusChanged( 406 sal_Bool isInsideCollectedElement ) 407 throw (com::sun::star::uno::RuntimeException); 408 virtual void SAL_CALL bufferStatusChanged( sal_Bool isBufferEmpty ) 409 throw (com::sun::star::uno::RuntimeException); 410 411 /* XXMLSecTester */ 412 virtual rtl::OUString SAL_CALL transfer_without_sec( 413 const rtl::OUString& inputFileName, 414 const rtl::OUString& outputFileName, 415 sal_Bool isBridgeInvolved) 416 throw (com::sun::star::uno::RuntimeException); 417 virtual rtl::OUString SAL_CALL export_xml( 418 const rtl::OUString& inputFileName, 419 const rtl::OUString& outputFileName, 420 sal_Bool isJavaBased) 421 throw (com::sun::star::uno::RuntimeException); 422 virtual rtl::OUString SAL_CALL import_xml( 423 const rtl::OUString& inputFileName, 424 const rtl::OUString& outputFileName, 425 sal_Bool isJavaBased) 426 throw (com::sun::star::uno::RuntimeException); 427 428 virtual void SAL_CALL setCryptoDir( 429 const rtl::OUString & javaDirName, 430 const rtl::OUString & cDirName) 431 throw (com::sun::star::uno::RuntimeException); 432 433 /* XDocumentHandler */ 434 virtual void SAL_CALL endDocument() 435 throw (com::sun::star::uno::RuntimeException); 436 virtual void SAL_CALL startDocument() 437 throw (com::sun::star::uno::RuntimeException); 438 virtual void SAL_CALL characters(const class rtl::OUString&) 439 throw (com::sun::star::uno::RuntimeException); 440 virtual void SAL_CALL processingInstruction(const rtl::OUString&, const rtl::OUString&) 441 throw (com::sun::star::uno::RuntimeException); 442 virtual void SAL_CALL ignorableWhitespace(const rtl::OUString&) 443 throw (com::sun::star::uno::RuntimeException); 444 virtual void SAL_CALL startElement( 445 const rtl::OUString&, 446 const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList >&) 447 throw (com::sun::star::uno::RuntimeException); 448 virtual void SAL_CALL endElement(const rtl::OUString&) 449 throw (com::sun::star::uno::RuntimeException); 450 virtual void SAL_CALL setDocumentLocator( 451 const com::sun::star::uno::Reference< com::sun::star::xml::sax::XLocator >&) 452 throw (com::sun::star::uno::RuntimeException); 453 }; 454 455 rtl::OUString XSecTester::parseFile( 456 const rtl::OUString& ouInputFileName, 457 const rtl::OUString& ouOutputFileName, 458 bool bIsExporting, 459 bool bIsJavaBased) 460 { 461 rtl::OUString ouMessage; 462 463 cssu::Reference<cssi::XInputStream> xInputStream = OpenInputStream(ouInputFileName); 464 465 if (xInputStream != NULL ) 466 { 467 /* initialization */ 468 rtl::OUString SEInitializer_comp; 469 rtl::OUString XMLSignature_comp; 470 rtl::OUString tokenPath; 471 cssu::Reference < cssxc::XSEInitializer > xSEInitializer; 472 473 if (bIsJavaBased) 474 { 475 SEInitializer_comp = rtl::OUString::createFromAscii( SEINITIALIZER_JAVA_COMPONENT ); 476 XMLSignature_comp = rtl::OUString::createFromAscii( XMLSIGNATURE_JAVA_COMPONENT); 477 m_ouXMLDocumentWrapperComponentName = rtl::OUString::createFromAscii( XMLDOCUMENTWRAPPER_JAVA_COMPONENT ); 478 tokenPath = m_ouJavaCryptokenDir; 479 } 480 else 481 { 482 SEInitializer_comp = rtl::OUString::createFromAscii( SEINITIALIZER_C_COMPONENT ); 483 XMLSignature_comp = rtl::OUString::createFromAscii( XMLSIGNATURE_C_COMPONENT); 484 m_ouXMLDocumentWrapperComponentName = rtl::OUString::createFromAscii( XMLDOCUMENT_C_COMPONENT ); 485 tokenPath = m_ouCCryptokenDir; 486 } 487 488 xSEInitializer = cssu::Reference < cssxc::XSEInitializer > ( 489 mxMSF->createInstance( SEInitializer_comp ), 490 cssu::UNO_QUERY ); 491 492 m_xXMLSignature = cssu::Reference<cssxc::XXMLSignature> ( 493 mxMSF->createInstance( XMLSignature_comp ), 494 cssu::UNO_QUERY ); 495 496 if ( xSEInitializer.is() && m_xXMLSignature.is()) 497 { 498 /* create SAX Parser */ 499 const rtl::OUString sSaxParser ( 500 RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.xml.sax.Parser") ); 501 m_xSaxParser = cssu::Reference < cssxs::XParser > ( mxMSF->createInstance( sSaxParser ), cssu::UNO_QUERY ); 502 503 /* create SAX Writer */ 504 const rtl::OUString sSaxWriter ( 505 RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.xml.sax.Writer") ); 506 cssu::Reference < cssi::XActiveDataSource > xSaxWriter 507 ( mxMSF->createInstance( sSaxWriter ), cssu::UNO_QUERY ); 508 509 cssu::Reference< cssi::XOutputStream > xOutputStream = OpenOutputStream(ouOutputFileName); 510 xSaxWriter->setOutputStream( xOutputStream ); 511 512 cssxs::InputSource aInput; 513 aInput.sSystemId = ouInputFileName; 514 aInput.aInputStream = xInputStream; 515 516 cssu::Reference < cssxs::XDocumentHandler > xSaxWriterHandler( xSaxWriter, cssu::UNO_QUERY); 517 518 m_xXMLSecurityContext = 519 xSEInitializer->createSecurityContext(tokenPath); 520 521 m_bIsExporting = bIsExporting; 522 m_xExportHandler = xSaxWriterHandler; 523 m_xOutputHandler = xSaxWriterHandler; 524 525 m_xXMLDocumentWrapper = NULL; 526 m_xSAXEventKeeper = NULL; 527 m_bIsSAXEventKeeperOnTheSAXChain = false; 528 529 m_bIsBlocking = false; 530 m_bIsInsideCollectedElement = false; 531 532 OSL_ASSERT(m_vSignatureList.size() == 0); 533 OSL_ASSERT(m_vUnsolvedReferenceURIs.size() == 0); 534 OSL_ASSERT(m_vUnsolvedReferenceKeeperIds.size() == 0); 535 OSL_ASSERT(m_vUnsolvedReferenceRefNums.size() == 0); 536 OSL_ASSERT(m_stCurrentPath.empty()); 537 OSL_ASSERT(m_stCurrentPathType.empty()); 538 OSL_ASSERT(m_vAncestorEvents.empty()); 539 540 changeOutput(); 541 542 /* foundSecurityRelated(); */ 543 544 /* Begin to parse */ 545 TimeValue startTime, endTime; 546 osl_getSystemTime( &startTime ); 547 548 xSaxWriterHandler->startDocument(); 549 550 if (m_bIsExporting) 551 { 552 m_xSaxParser->setDocumentHandler(this); 553 m_xSaxParser->parseStream(aInput); 554 } 555 else 556 { 557 m_xSaxParser->setDocumentHandler(this); 558 m_xSaxParser->parseStream(aInput); 559 } 560 561 endMission(); 562 xSaxWriterHandler->endDocument(); 563 564 osl_getSystemTime( &endTime ); 565 566 flushAncestorEvents( NULL ); 567 568 // Bug in SAXWriter, done in endDocument() 569 // xOutputStream->closeOutput(); 570 xInputStream->closeInput(); 571 572 573 /* 574 * Free the security context 575 */ 576 xSEInitializer->freeSecurityContext(m_xXMLSecurityContext); 577 m_xXMLSecurityContext = NULL; 578 579 /* Calculate the time */ 580 double diff = ((double)((endTime.Nanosec + endTime.Seconds*1000000000.0) 581 - (startTime.Nanosec + startTime.Seconds*1000000000.0))) / 582 ((double)1000000000.0); 583 584 char buf[32]; 585 sprintf(buf, "%.2f", diff); 586 ouMessage += rtl::OUString(RTL_ASCII_USTRINGPARAM(buf)); 587 } 588 else 589 { 590 ouMessage += rtl::OUString::createFromAscii( "N/A" ); 591 } 592 593 } 594 else 595 { 596 ouMessage += rtl::OUString::createFromAscii( "-" ); 597 } 598 599 return ouMessage; 600 } 601 602 /* XSignatureCreationResultListener */ 603 void SAL_CALL XSecTester::signatureCreated( 604 sal_Int32 securityId, 605 cssxc::SecurityOperationStatus creationResult ) 606 throw (cssu::RuntimeException) 607 { 608 m_nTotalSignatureNumber++; 609 if (creationResult == cssxc::SecurityOperationStatus_OPERATION_SUCCEEDED) 610 { 611 m_nSuccessfulSignatureNumber++; 612 } 613 } 614 615 /* XSignatureVerifyResultListener */ 616 void SAL_CALL XSecTester::signatureVerified( 617 sal_Int32 securityId, 618 cssxc::SecurityOperationStatus verifyResult ) 619 throw (cssu::RuntimeException) 620 { 621 m_nTotalSignatureNumber++; 622 if (verifyResult == cssxc::SecurityOperationStatus_OPERATION_SUCCEEDED) 623 { 624 m_nSuccessfulSignatureNumber++; 625 } 626 } 627 628 /* XSAXEventKeeperStatusChangeListener */ 629 void SAL_CALL XSecTester::blockingStatusChanged( sal_Bool isBlocking ) 630 throw (cssu::RuntimeException) 631 { 632 this->m_bIsBlocking = isBlocking; 633 } 634 635 void SAL_CALL XSecTester::collectionStatusChanged( sal_Bool isInsideCollectedElement ) 636 throw (cssu::RuntimeException) 637 { 638 this->m_bIsInsideCollectedElement = isInsideCollectedElement; 639 640 if ( !m_bIsInsideCollectedElement && !m_bIsBlocking) 641 { 642 m_bIsSAXEventKeeperOnTheSAXChain = false; 643 } 644 else 645 { 646 m_bIsSAXEventKeeperOnTheSAXChain = true; 647 } 648 changeOutput(); 649 } 650 651 void SAL_CALL XSecTester::bufferStatusChanged( sal_Bool isBufferEmpty ) 652 throw (cssu::RuntimeException) 653 { 654 if (isBufferEmpty) 655 { 656 m_xXMLDocumentWrapper = NULL; 657 658 m_xSAXEventKeeper = NULL; 659 m_bIsSAXEventKeeperOnTheSAXChain = false; 660 changeOutput(); 661 } 662 } 663 664 /* XXMLSecTester */ 665 rtl::OUString SAL_CALL XSecTester::export_xml( const rtl::OUString& inputFileName, const rtl::OUString& outputFileName, sal_Bool isJavaBased) 666 throw (cssu::RuntimeException) 667 { 668 rtl::OUString ouMessage; 669 670 m_nTotalSignatureNumber = 0; 671 m_nSuccessfulSignatureNumber = 0; 672 673 ouMessage += parseFile(inputFileName, outputFileName, sal_True, isJavaBased); 674 675 rtl::OUString ouRemark = rtl::OUString::valueOf(m_nSuccessfulSignatureNumber) + 676 rtl::OUString(RTL_ASCII_USTRINGPARAM( "/" )) 677 + rtl::OUString::valueOf(m_nTotalSignatureNumber); 678 ouMessage += rtl::OUString(RTL_ASCII_USTRINGPARAM("\t")) + ouRemark; 679 680 return ouMessage; 681 } 682 683 rtl::OUString SAL_CALL XSecTester::import_xml( const rtl::OUString& inputFileName, const rtl::OUString& outputFileName, sal_Bool isJavaBased) 684 throw (cssu::RuntimeException) 685 { 686 rtl::OUString ouMessage; 687 688 m_nTotalSignatureNumber = 0; 689 m_nSuccessfulSignatureNumber = 0; 690 691 ouMessage += parseFile(inputFileName, outputFileName, sal_False, isJavaBased); 692 693 rtl::OUString ouRemark = rtl::OUString::valueOf(m_nSuccessfulSignatureNumber) + 694 rtl::OUString(RTL_ASCII_USTRINGPARAM( "/" )) 695 + rtl::OUString::valueOf(m_nTotalSignatureNumber); 696 ouMessage += rtl::OUString(RTL_ASCII_USTRINGPARAM("\t")) + ouRemark; 697 698 return ouMessage; 699 } 700 701 rtl::OUString SAL_CALL XSecTester::transfer_without_sec( 702 const rtl::OUString& inputFileName, 703 const rtl::OUString& outputFileName, 704 sal_Bool isBridgeInvolved) 705 throw (cssu::RuntimeException) 706 { 707 rtl::OUString ouMessage; 708 709 cssu::Reference< cssi::XInputStream > xInputStream = OpenInputStream(inputFileName); 710 711 if (xInputStream != NULL ) 712 { 713 /* create SAX Parser */ 714 const rtl::OUString sSaxParser ( 715 RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.xml.sax.Parser") ); 716 m_xSaxParser = cssu::Reference < cssxs::XParser > ( mxMSF->createInstance( sSaxParser ), cssu::UNO_QUERY ); 717 718 /* create SAX Writer */ 719 const rtl::OUString sSaxWriter ( 720 RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.xml.sax.Writer") ); 721 cssu::Reference < cssi::XActiveDataSource > xSaxWriter 722 ( mxMSF->createInstance( sSaxWriter ), cssu::UNO_QUERY ); 723 cssu::Reference < cssxs::XDocumentHandler > xSaxWriterHandler( 724 xSaxWriter, cssu::UNO_QUERY); 725 726 if (!isBridgeInvolved) 727 { 728 /* connect the SAX Parser and the SAX Writer */ 729 m_xSaxParser->setDocumentHandler ( xSaxWriterHandler ); 730 } 731 else 732 { 733 /* create Java Flat Filter */ 734 const rtl::OUString sJavaFlatFilter( 735 RTL_CONSTASCII_USTRINGPARAM( JAVAFLATFILTER_COMPONENT ) ); 736 cssu::Reference < cssxs::XParser > xJavaFilterParser 737 ( mxMSF->createInstance( sJavaFlatFilter ), cssu::UNO_QUERY ); 738 cssu::Reference < cssxs::XDocumentHandler > xJavaFilterHandler( 739 xJavaFilterParser, cssu::UNO_QUERY ); 740 741 if ( !xJavaFilterParser.is() ) 742 return rtl::OUString::createFromAscii( "NO JAVA" ); 743 744 /* connect the SAX Parser, the Java Flat Filter and the SAX Writer */ 745 xJavaFilterParser->setDocumentHandler( xSaxWriterHandler ); 746 m_xSaxParser->setDocumentHandler ( xJavaFilterHandler ); 747 } 748 749 750 /* set output stream */ 751 cssu::Reference< cssi::XOutputStream > xOutputStream = 752 OpenOutputStream(outputFileName); 753 xSaxWriter->setOutputStream( xOutputStream ); 754 755 /* prepare input stream */ 756 cssxs::InputSource aInput; 757 aInput.sSystemId = inputFileName; 758 aInput.aInputStream = xInputStream; 759 760 TimeValue startTime, endTime; 761 osl_getSystemTime( &startTime ); 762 763 m_xSaxParser->parseStream ( aInput ); 764 765 // xOutputStream->closeOutput(); 766 xInputStream->closeInput(); 767 768 osl_getSystemTime( &endTime ); 769 770 double diff = ((double)((endTime.Nanosec + endTime.Seconds*1000000000.0) 771 - (startTime.Nanosec + startTime.Seconds*1000000000.0)))/((double)1000000000.0); 772 char buf[32]; 773 sprintf(buf, "%.2f", diff); 774 ouMessage += rtl::OUString(RTL_ASCII_USTRINGPARAM(buf)); 775 } 776 777 return ouMessage; 778 } 779 780 void SAL_CALL XSecTester::setCryptoDir(const rtl::OUString & javaDirName, const rtl::OUString & cDirName) 781 throw (cssu::RuntimeException) 782 { 783 m_ouJavaCryptokenDir = javaDirName; 784 m_ouCCryptokenDir = cDirName; 785 } 786 787 788 cssu::Reference< cssu::XInterface > SAL_CALL XSecTester_createInstance( 789 const cssu::Reference< cssl::XMultiServiceFactory > & rSMgr) 790 throw( cssu::Exception ) 791 { 792 return (cppu::OWeakObject*) new XSecTester( rSMgr ); 793 } 794 795 int SecurityEntity::m_nNextSecurityId = 1; 796 797 SecurityEntity::SecurityEntity( 798 const cssu::Reference<cssxc::sax::XSecuritySAXEventKeeper>& xSAXEventKeeper, 799 const cssu::Reference<cssxc::XXMLSecurityContext>& xXMLSecurityContext, 800 const cssu::Reference<cssxc::XXMLSignature>& xXMLSignature, 801 const cssu::Reference< cssl::XMultiServiceFactory > &rsMSF) 802 :m_xSAXEventKeeper(xSAXEventKeeper), 803 m_xXMLSecurityContext(xXMLSecurityContext), 804 m_xXMLSignature(xXMLSignature), 805 mxMSF(rsMSF), 806 m_ouKeyURI(RTL_ASCII_USTRINGPARAM("")) 807 { 808 m_nSecurityId = getNextSecurityId(); 809 } 810 811 int SecurityEntity::getNextSecurityId() const 812 { 813 int nId = m_nNextSecurityId++; 814 return nId; 815 } 816 817 void SecurityEntity::setKeyId(int nId) 818 { 819 cssu::Reference<cssxc::sax::XKeyCollector> keyCollector (m_xReferenceListener, cssu::UNO_QUERY); 820 keyCollector->setKeyId(nId); 821 } 822 823 824 void SecurityEntity::setKeyURI(const rtl::OUString& ouUri) 825 { 826 m_ouKeyURI = ouUri; 827 } 828 829 cssu::Reference<cssxc::sax::XReferenceResolvedListener> SecurityEntity::getReferenceListener() const 830 { 831 return m_xReferenceListener; 832 } 833 834 int SecurityEntity::getSecurityId() const 835 { 836 return m_nSecurityId; 837 } 838 839 bool SecurityEntity::setKey(const rtl::OUString& ouUri, bool bIsExporting) 840 { 841 bool rc = false; 842 843 if (m_ouKeyURI != rtl::OUString(RTL_ASCII_USTRINGPARAM("")) && 844 m_ouKeyURI == ouUri) 845 { 846 int nKeeperId = m_xSAXEventKeeper->addSecurityElementCollector( 847 bIsExporting ? 848 (cssxc::sax::ElementMarkPriority_BEFOREMODIFY): 849 (cssxc::sax::ElementMarkPriority_AFTERMODIFY), 850 true); 851 852 setKeyId(nKeeperId); 853 m_xSAXEventKeeper->setSecurityId(nKeeperId, m_nSecurityId); 854 855 cssu::Reference<cssxc::sax::XReferenceResolvedBroadcaster> xReferenceResolvedBroadcaster 856 (m_xSAXEventKeeper, cssu::UNO_QUERY); 857 xReferenceResolvedBroadcaster->addReferenceResolvedListener(nKeeperId, 858 m_xReferenceListener); 859 860 rc = true; 861 } 862 863 return rc; 864 } 865 866 bool SecurityEntity::endMission() 867 { 868 cssu::Reference<cssxc::sax::XMissionTaker> xMissionTaker 869 (m_xReferenceListener, cssu::UNO_QUERY); 870 871 return xMissionTaker->endMission(); 872 } 873 874 SignatureEntity::SignatureEntity( 875 const cssu::Reference<cssxc::sax::XSecuritySAXEventKeeper>& xSAXEventKeeper, 876 bool bIsExporting, 877 XSecTester* pListener, 878 const cssu::Reference<cssxc::XXMLSecurityContext>& xXMLSecurityContext, 879 const cssu::Reference<cssxc::XXMLSignature>& xXMLSignature, 880 const cssu::Reference< cssl::XMultiServiceFactory >& rsMSF) 881 :SecurityEntity(xSAXEventKeeper, 882 xXMLSecurityContext, 883 xXMLSignature, 884 rsMSF) 885 { 886 if (bIsExporting) 887 { 888 m_nSignatureElementCollectorId = 889 m_xSAXEventKeeper->addSecurityElementCollector( 890 cssxc::sax::ElementMarkPriority_AFTERMODIFY, 891 true); 892 893 m_xSAXEventKeeper->setSecurityId(m_nSignatureElementCollectorId, m_nSecurityId); 894 895 m_xReferenceListener = cssu::Reference< cssxc::sax::XReferenceResolvedListener >( 896 mxMSF->createInstance( rtl::OUString::createFromAscii( SIGNATURECREATOR_COMPONENT )), 897 cssu::UNO_QUERY); 898 899 cssu::Reference<cssl::XInitialization> xInitialization(m_xReferenceListener, cssu::UNO_QUERY); 900 901 cssu::Sequence<cssu::Any> args(5); 902 char buf[16]; 903 904 sprintf(buf, "%d", m_nSecurityId); 905 args[0] = cssu::makeAny(rtl::OUString(RTL_ASCII_USTRINGPARAM(buf))); 906 args[1] = cssu::makeAny(m_xSAXEventKeeper); 907 908 sprintf(buf, "%d", m_nSignatureElementCollectorId); 909 args[2] = cssu::makeAny(rtl::OUString(RTL_ASCII_USTRINGPARAM(buf))); 910 args[3] = cssu::makeAny(m_xXMLSecurityContext->getSecurityEnvironment()); 911 args[4] = cssu::makeAny(m_xXMLSignature); 912 913 xInitialization->initialize(args); 914 915 int nBlockerId = m_xSAXEventKeeper->addBlocker(); 916 m_xSAXEventKeeper->setSecurityId(nBlockerId, m_nSecurityId); 917 918 cssu::Reference<cssxc::sax::XBlockerMonitor> xBlockerMonitor(m_xReferenceListener, cssu::UNO_QUERY); 919 xBlockerMonitor->setBlockerId(nBlockerId); 920 921 cssu::Reference< cssxc::sax::XSignatureCreationResultBroadcaster > xSignatureCreationResultBroadcaster 922 (m_xReferenceListener, cssu::UNO_QUERY); 923 xSignatureCreationResultBroadcaster->addSignatureCreationResultListener(pListener); 924 } 925 else 926 { 927 m_nSignatureElementCollectorId = 928 m_xSAXEventKeeper->addSecurityElementCollector( 929 cssxc::sax::ElementMarkPriority_BEFOREMODIFY, 930 false); 931 932 m_xSAXEventKeeper->setSecurityId(m_nSignatureElementCollectorId, m_nSecurityId); 933 934 m_xReferenceListener = cssu::Reference< cssxc::sax::XReferenceResolvedListener >( 935 mxMSF->createInstance( rtl::OUString::createFromAscii( SIGNATUREVERIFIER_COMPONENT )), 936 cssu::UNO_QUERY); 937 938 cssu::Reference<cssl::XInitialization> xInitialization(m_xReferenceListener, cssu::UNO_QUERY); 939 940 cssu::Sequence<cssu::Any> args(5); 941 char buf[16]; 942 943 sprintf(buf, "%d", m_nSecurityId); 944 args[0] = cssu::makeAny(rtl::OUString(RTL_ASCII_USTRINGPARAM(buf))); 945 args[1] = cssu::makeAny(m_xSAXEventKeeper); 946 947 sprintf(buf, "%d", m_nSignatureElementCollectorId); 948 args[2] = cssu::makeAny(rtl::OUString(RTL_ASCII_USTRINGPARAM(buf))); 949 args[3] = cssu::makeAny(m_xXMLSecurityContext); 950 args[4] = cssu::makeAny(m_xXMLSignature); 951 xInitialization->initialize(args); 952 953 cssu::Reference< cssxc::sax::XSignatureVerifyResultBroadcaster > xSignatureVerifyResultBroadcaster 954 (m_xReferenceListener, cssu::UNO_QUERY); 955 xSignatureVerifyResultBroadcaster->addSignatureVerifyResultListener(pListener); 956 } 957 958 cssu::Reference<cssxc::sax::XReferenceResolvedBroadcaster> xReferenceResolvedBroadcaster 959 (m_xSAXEventKeeper, cssu::UNO_QUERY); 960 xReferenceResolvedBroadcaster->addReferenceResolvedListener( 961 m_nSignatureElementCollectorId, m_xReferenceListener); 962 } 963 964 void SignatureEntity::addReferenceURI(const rtl::OUString& ouUri) 965 { 966 m_vReferenceIds.push_back(ouUri); 967 } 968 969 void SignatureEntity::setReferenceNumber() const 970 { 971 cssu::Reference<cssxc::sax::XReferenceCollector> xReferenceCollector 972 (m_xReferenceListener, cssu::UNO_QUERY); 973 xReferenceCollector->setReferenceCount(m_vReferenceIds.size()); 974 } 975 976 bool SignatureEntity::hasReference(const rtl::OUString& ouUri) const 977 { 978 bool rc = false; 979 980 std::vector<const rtl::OUString>::const_iterator ii; 981 for (ii = m_vReferenceIds.begin(); ii != m_vReferenceIds.end(); ++ii) 982 { 983 if (ouUri == *ii) 984 { 985 rc = true; 986 break; 987 } 988 } 989 990 return rc; 991 } 992 993 bool SignatureEntity::setReference(const rtl::OUString& ouUri, bool bIsExporting) const 994 { 995 bool rc = false; 996 997 if (hasReference(ouUri)) 998 { 999 int nKeeperId = m_xSAXEventKeeper->addSecurityElementCollector( 1000 bIsExporting ? 1001 (cssxc::sax::ElementMarkPriority_AFTERMODIFY): 1002 (cssxc::sax::ElementMarkPriority_BEFOREMODIFY), 1003 false); 1004 1005 m_xSAXEventKeeper->setSecurityId(nKeeperId, m_nSecurityId); 1006 1007 cssu::Reference<cssxc::sax::XReferenceResolvedBroadcaster> xReferenceResolvedBroadcaster 1008 (m_xSAXEventKeeper, cssu::UNO_QUERY); 1009 xReferenceResolvedBroadcaster->addReferenceResolvedListener(nKeeperId, m_xReferenceListener); 1010 1011 cssu::Reference<cssxc::sax::XReferenceCollector> xReferenceCollector 1012 (m_xReferenceListener, cssu::UNO_QUERY); 1013 xReferenceCollector->setReferenceId(nKeeperId); 1014 1015 rc = true; 1016 } 1017 1018 return rc; 1019 } 1020 1021 /* XDocumentHandler */ 1022 void SAL_CALL XSecTester::startDocument() 1023 throw (cssu::RuntimeException) 1024 { 1025 } 1026 1027 void SAL_CALL XSecTester::endDocument() 1028 throw (cssu::RuntimeException) 1029 { 1030 } 1031 1032 void SAL_CALL XSecTester::characters(const class rtl::OUString & chars) 1033 throw (cssu::RuntimeException) 1034 { 1035 m_xExportHandler->characters(chars); 1036 } 1037 1038 void SAL_CALL XSecTester::processingInstruction(const rtl::OUString & target, const rtl::OUString &data) 1039 throw (cssu::RuntimeException) 1040 { 1041 m_xExportHandler->processingInstruction(target, data); 1042 } 1043 1044 void SAL_CALL XSecTester::ignorableWhitespace(const rtl::OUString &) 1045 throw (cssu::RuntimeException) 1046 { 1047 1048 } 1049 1050 void SAL_CALL XSecTester::startElement(const rtl::OUString & name, const cssu::Reference<cssxs::XAttributeList> &xAttribs) 1051 throw (cssu::RuntimeException) 1052 { 1053 rtl::OUString ouIdAttr = xAttribs->getValueByName( 1054 rtl::OUString(RTL_ASCII_USTRINGPARAM("id"))); 1055 1056 if (ouIdAttr == NULL) 1057 { 1058 ouIdAttr = xAttribs->getValueByName( 1059 rtl::OUString(RTL_ASCII_USTRINGPARAM("Id"))); 1060 } 1061 1062 bool bHasIdAttr = (ouIdAttr != NULL && ouIdAttr.getLength() > 0 ); 1063 bool needResend = false; 1064 1065 if (bHasIdAttr || name.equalsAscii( SIGNATURE_STR )) 1066 { 1067 if (foundSecurityRelated() && ! m_bIsExporting) 1068 { 1069 needResend = true; 1070 } 1071 } 1072 1073 if ( !m_bIsSAXEventKeeperOnTheSAXChain ) 1074 { 1075 addStartAncestorEvent(name, xAttribs); 1076 } 1077 1078 bool bSuppressingForwarding = checkSecurityElement(name, xAttribs); 1079 1080 checkReference(name, xAttribs, ouIdAttr); 1081 1082 if (needResend) 1083 { 1084 m_xSAXEventKeeper->setNextHandler(NULL); 1085 1086 cssu::Reference<cssxs::XDocumentHandler> xSAXEventKeeperHandler 1087 (m_xSAXEventKeeper, cssu::UNO_QUERY); 1088 1089 xSAXEventKeeperHandler->startElement(name, xAttribs); 1090 m_xSAXEventKeeper->setNextHandler(this); 1091 } 1092 1093 if (!bSuppressingForwarding) 1094 { 1095 m_xExportHandler->startElement(name, xAttribs); 1096 } 1097 } 1098 1099 void SAL_CALL XSecTester::endElement(const rtl::OUString& name) 1100 throw (cssu::RuntimeException) 1101 { 1102 if (!m_stCurrentPath.empty()) 1103 { 1104 void* pSignedInfo = m_stCurrentPath.top(); 1105 bool bIsStringType = m_stCurrentPathType.top(); 1106 1107 m_stCurrentPath.pop(); 1108 m_stCurrentPathType.pop(); 1109 1110 if (bIsStringType && !strcmp((const char *)pSignedInfo, SIGNEDINFO_STR)) 1111 { 1112 if (!m_stCurrentPath.empty()) 1113 { 1114 void* pSignature = m_stCurrentPath.top(); 1115 bIsStringType = m_stCurrentPathType.top(); 1116 1117 if (!bIsStringType && pSignature != NULL) 1118 { 1119 ((SignatureEntity *) pSignature)->setReferenceNumber(); 1120 } 1121 } 1122 } 1123 } 1124 1125 if ( !m_bIsSAXEventKeeperOnTheSAXChain ) 1126 { 1127 addEndAncestorEvent(name); 1128 } 1129 1130 m_xExportHandler->endElement(name); 1131 } 1132 1133 void SAL_CALL XSecTester::setDocumentLocator( const cssu::Reference<cssxs::XLocator>& ) 1134 throw (cssu::RuntimeException) 1135 { 1136 } 1137 1138 void XSecTester::changeOutput() 1139 { 1140 if (m_bIsExporting) 1141 { 1142 if (m_bIsSAXEventKeeperOnTheSAXChain) 1143 { 1144 m_xExportHandler = cssu::Reference<cssxs::XDocumentHandler> 1145 (m_xSAXEventKeeper, cssu::UNO_QUERY); 1146 1147 m_xSAXEventKeeper->setNextHandler(NULL); 1148 1149 flushAncestorEvents(m_xExportHandler); 1150 1151 m_xSAXEventKeeper->setNextHandler(m_xOutputHandler); 1152 } 1153 else 1154 { 1155 m_xExportHandler = m_xOutputHandler; 1156 } 1157 } 1158 else 1159 { 1160 if (m_bIsSAXEventKeeperOnTheSAXChain) 1161 { 1162 cssu::Reference<cssxs::XDocumentHandler> xSAXEventKeeperHandler 1163 (m_xSAXEventKeeper, cssu::UNO_QUERY); 1164 1165 m_xSAXEventKeeper->setNextHandler(NULL); 1166 1167 flushAncestorEvents(xSAXEventKeeperHandler); 1168 1169 m_xSaxParser->setDocumentHandler(xSAXEventKeeperHandler); 1170 m_xSAXEventKeeper->setNextHandler(this); 1171 } 1172 else 1173 { 1174 m_xSaxParser->setDocumentHandler(this); 1175 } 1176 1177 } 1178 } 1179 1180 bool XSecTester::foundSecurityRelated() 1181 { 1182 if (m_xSAXEventKeeper == NULL) 1183 { 1184 m_bIsBlocking = false; 1185 m_bIsInsideCollectedElement = false; 1186 1187 m_xXMLDocumentWrapper = cssu::Reference<cssxw::XXMLDocumentWrapper> 1188 (mxMSF->createInstance( m_ouXMLDocumentWrapperComponentName ), 1189 cssu::UNO_QUERY); 1190 1191 m_xSAXEventKeeper = cssu::Reference< cssxc::sax::XSecuritySAXEventKeeper > 1192 (mxMSF->createInstance( rtl::OUString::createFromAscii( SAXEVENTKEEPER_COMPONENT )), 1193 cssu::UNO_QUERY); 1194 1195 cssu::Reference<cssl::XInitialization> xInitialization(m_xSAXEventKeeper, cssu::UNO_QUERY); 1196 1197 cssu::Sequence <cssu::Any> arg(1); 1198 arg[0] = cssu::makeAny(m_xXMLDocumentWrapper); 1199 xInitialization->initialize(arg); 1200 1201 cssu::Reference<cssxc::sax::XSAXEventKeeperStatusChangeBroadcaster> 1202 xSAXEventKeeperStatusChangeBroadcaster(m_xSAXEventKeeper, cssu::UNO_QUERY); 1203 xSAXEventKeeperStatusChangeBroadcaster->addSAXEventKeeperStatusChangeListener(this); 1204 } 1205 1206 bool rc = false; 1207 1208 if (!m_bIsSAXEventKeeperOnTheSAXChain) 1209 { 1210 rc = true; 1211 } 1212 1213 m_bIsSAXEventKeeperOnTheSAXChain=true; 1214 changeOutput(); 1215 1216 return rc; 1217 } 1218 1219 void XSecTester::findKeyOrReference(SecurityEntity* pSecurityEntity, const rtl::OUString& ouUri, bool bIsFindingKey) 1220 { 1221 std::vector<rtl::OUString>::iterator ii_referenceURIs; 1222 std::vector<int>::iterator ii_referenceKeeperIds; 1223 std::vector<int>::iterator ii_referenceRefNums; 1224 1225 for (ii_referenceURIs = m_vUnsolvedReferenceURIs.begin(), 1226 ii_referenceKeeperIds = m_vUnsolvedReferenceKeeperIds.begin(), 1227 ii_referenceRefNums = m_vUnsolvedReferenceRefNums.begin(); 1228 ii_referenceURIs != m_vUnsolvedReferenceURIs.end(); ) 1229 { 1230 rtl::OUString ouReferenceUri = *ii_referenceURIs; 1231 1232 if (ouReferenceUri == ouUri) 1233 { 1234 int nKeeperId = *ii_referenceKeeperIds; 1235 int nRefNum = *ii_referenceRefNums; 1236 1237 if ( bIsFindingKey ) 1238 { 1239 int nClonedKeeperId = m_xSAXEventKeeper->cloneElementCollector( 1240 nKeeperId, 1241 m_bIsExporting? 1242 (cssxc::sax::ElementMarkPriority_BEFOREMODIFY): 1243 (cssxc::sax::ElementMarkPriority_AFTERMODIFY)); 1244 1245 pSecurityEntity->setKeyId(nClonedKeeperId); 1246 1247 m_xSAXEventKeeper->setSecurityId(nClonedKeeperId, pSecurityEntity->getSecurityId()); 1248 1249 cssu::Reference<cssxc::sax::XReferenceResolvedBroadcaster> 1250 xReferenceResolvedBroadcaster(m_xSAXEventKeeper, cssu::UNO_QUERY); 1251 xReferenceResolvedBroadcaster->addReferenceResolvedListener( 1252 nClonedKeeperId, 1253 pSecurityEntity->getReferenceListener()); 1254 } 1255 else 1256 { 1257 int nClonedKeeperId = m_xSAXEventKeeper->cloneElementCollector( 1258 nKeeperId, 1259 m_bIsExporting? 1260 (cssxc::sax::ElementMarkPriority_AFTERMODIFY): 1261 (cssxc::sax::ElementMarkPriority_BEFOREMODIFY)); 1262 1263 m_xSAXEventKeeper->setSecurityId(nClonedKeeperId, pSecurityEntity->getSecurityId()); 1264 1265 cssu::Reference<cssxc::sax::XReferenceResolvedBroadcaster> 1266 xReferenceResolvedBroadcaster 1267 (m_xSAXEventKeeper, cssu::UNO_QUERY); 1268 xReferenceResolvedBroadcaster->addReferenceResolvedListener( 1269 nClonedKeeperId, 1270 pSecurityEntity->getReferenceListener()); 1271 1272 cssu::Reference<cssxc::sax::XReferenceCollector> xReferenceCollector 1273 (pSecurityEntity->getReferenceListener(), cssu::UNO_QUERY); 1274 xReferenceCollector->setReferenceId(nClonedKeeperId); 1275 } 1276 1277 nRefNum--; 1278 if (nRefNum == 0) 1279 { 1280 m_xSAXEventKeeper->removeElementCollector(nKeeperId); 1281 1282 ii_referenceURIs = m_vUnsolvedReferenceURIs.erase(ii_referenceURIs); 1283 ii_referenceKeeperIds = m_vUnsolvedReferenceKeeperIds.erase(ii_referenceKeeperIds); 1284 ii_referenceRefNums = m_vUnsolvedReferenceRefNums.erase(ii_referenceRefNums); 1285 } 1286 else 1287 { 1288 (*ii_referenceRefNums) = nRefNum; 1289 1290 ii_referenceURIs++; 1291 ii_referenceKeeperIds++; 1292 ii_referenceRefNums++; 1293 } 1294 1295 if (bIsFindingKey) 1296 { 1297 break; 1298 } 1299 } 1300 else 1301 { 1302 ii_referenceURIs++; 1303 ii_referenceKeeperIds++; 1304 ii_referenceRefNums++; 1305 } 1306 } 1307 } 1308 1309 bool XSecTester::checkSecurityElement( 1310 const rtl::OUString& ouLocalName, 1311 const cssu::Reference<cssxs::XAttributeList>& xAttribs) 1312 { 1313 bool rc = false; 1314 1315 if (ouLocalName.equalsAscii(SIGNATURE_STR)) 1316 { 1317 SignatureEntity* pSignatureEntity = new SignatureEntity( 1318 m_xSAXEventKeeper, 1319 m_bIsExporting, 1320 this, 1321 m_xXMLSecurityContext, 1322 m_xXMLSignature, 1323 mxMSF); 1324 1325 m_vSignatureList.push_back(pSignatureEntity); 1326 1327 m_stCurrentPath.push(pSignatureEntity); 1328 m_stCurrentPathType.push(false); 1329 } 1330 else if (ouLocalName.equalsAscii(REFERENCE_STR)) 1331 { 1332 if (!m_stCurrentPath.empty()) 1333 { 1334 void* pSignedInfo = m_stCurrentPath.top(); 1335 bool bIsStringType = m_stCurrentPathType.top(); 1336 1337 m_stCurrentPath.pop(); 1338 m_stCurrentPathType.pop(); 1339 1340 if (bIsStringType && !m_stCurrentPath.empty()) 1341 { 1342 void* pSignature = m_stCurrentPath.top(); 1343 bool bIsStringType2 = m_stCurrentPathType.top(); 1344 1345 if (!strcmp((const char*)pSignedInfo, SIGNEDINFO_STR) && !bIsStringType2) 1346 { 1347 rtl::OUString ouUri = xAttribs->getValueByName 1348 (rtl::OUString(RTL_ASCII_USTRINGPARAM( URI_ATTR_STR ))); 1349 1350 if (ouUri.matchAsciiL("#", 1, 0)) 1351 { 1352 rtl::OUString uri = ouUri.copy(1); 1353 SignatureEntity* pSignatureEntity = (SignatureEntity *)pSignature; 1354 1355 if (uri != NULL && uri.getLength()>0) 1356 { 1357 pSignatureEntity->addReferenceURI(uri); 1358 findKeyOrReference(pSignatureEntity, uri, true); 1359 } 1360 } 1361 } 1362 } 1363 m_stCurrentPath.push(pSignedInfo); 1364 m_stCurrentPathType.push(bIsStringType); 1365 } 1366 m_stCurrentPath.push( (void *)REFERENCE_STR); 1367 m_stCurrentPathType.push(true); 1368 } 1369 else if(ouLocalName.equalsAscii(KEYVALUE_STR) || 1370 ouLocalName.equalsAscii(KEYNAME_STR) || 1371 ouLocalName.equalsAscii(X509DATA_STR) || 1372 ouLocalName.equalsAscii(ENCRYPTEDKEY_STR)) 1373 { 1374 if (!m_stCurrentPath.empty()) 1375 { 1376 void* pKeyInfo = m_stCurrentPath.top(); 1377 bool bIsStringType = m_stCurrentPathType.top(); 1378 1379 m_stCurrentPath.pop(); 1380 m_stCurrentPathType.pop(); 1381 1382 if (bIsStringType && !m_stCurrentPath.empty()) 1383 { 1384 bool bIsStringType2 = m_stCurrentPathType.top(); 1385 1386 if (!bIsStringType2) 1387 { 1388 SecurityEntity *pSecurityEntity = 1389 (SecurityEntity *) (m_stCurrentPath.top()); 1390 pSecurityEntity->setKeyId(0); 1391 } 1392 } 1393 1394 m_stCurrentPath.push(pKeyInfo); 1395 m_stCurrentPathType.push(bIsStringType); 1396 } 1397 1398 m_stCurrentPath.push((void *)KEYVALUE_STR); 1399 m_stCurrentPathType.push(true); 1400 } 1401 else if(ouLocalName.equalsAscii(RETRIEVALMETHOD_STR)) 1402 { 1403 if (!m_stCurrentPath.empty()) 1404 { 1405 void* pKeyInfo = m_stCurrentPath.top(); 1406 bool bIsStringType = m_stCurrentPathType.top(); 1407 1408 m_stCurrentPath.pop(); 1409 m_stCurrentPathType.pop(); 1410 1411 if (bIsStringType && !m_stCurrentPath.empty()) 1412 { 1413 bool bIsStringType2 = m_stCurrentPathType.top(); 1414 1415 if (!bIsStringType2) 1416 { 1417 SecurityEntity *pSecurityEntity = 1418 (SecurityEntity *) m_stCurrentPath.top(); 1419 rtl::OUString ouUri = xAttribs->getValueByName( 1420 rtl::OUString(RTL_ASCII_USTRINGPARAM( URI_ATTR_STR ))); 1421 1422 if (!strcmp((const char *)pKeyInfo, KEYINFO_STR) && 1423 ouUri != NULL && ouUri.getLength()>0) 1424 { 1425 pSecurityEntity->setKeyURI(ouUri); 1426 findKeyOrReference(pSecurityEntity, ouUri, true); 1427 } 1428 } 1429 1430 } 1431 1432 m_stCurrentPath.push(pKeyInfo); 1433 m_stCurrentPathType.push(bIsStringType); 1434 } 1435 1436 m_stCurrentPath.push((void *)RETRIEVALMETHOD_STR); 1437 m_stCurrentPathType.push(true); 1438 } 1439 else if(ouLocalName.equalsAscii(KEYINFO_STR)) 1440 { 1441 m_stCurrentPath.push((void *)KEYINFO_STR); 1442 m_stCurrentPathType.push(true); 1443 } 1444 else if(ouLocalName.equalsAscii(SIGNEDINFO_STR)) 1445 { 1446 m_stCurrentPath.push((void *)SIGNEDINFO_STR); 1447 m_stCurrentPathType.push(true); 1448 } 1449 else 1450 { 1451 m_stCurrentPath.push((void *)OTHER_ELEMENT_STR); 1452 m_stCurrentPathType.push(true); 1453 } 1454 1455 return rc; 1456 } 1457 1458 void XSecTester::checkReference( 1459 const rtl::OUString& ouLocalName, 1460 const cssu::Reference<cssxs::XAttributeList>& xAttribs, 1461 const rtl::OUString& ouId) 1462 { 1463 rtl::OUString refNumStr = 1464 xAttribs->getValueByName(rtl::OUString(RTL_ASCII_USTRINGPARAM(REFNUM_ATTR_STR))); 1465 1466 if (ouId != NULL && ouId.getLength()>0 ) 1467 { 1468 int nRefNum = 999; 1469 if (refNumStr != NULL && refNumStr.getLength()>0 ) 1470 { 1471 nRefNum = refNumStr.toInt32(); 1472 } 1473 1474 int nLength = m_vSignatureList.size(); 1475 for (int i = 0; i<nLength; ++i) 1476 { 1477 SignatureEntity* pSignatureEntity = m_vSignatureList.at(i); 1478 1479 if (pSignatureEntity->setReference(ouId, m_bIsExporting)) 1480 { 1481 nRefNum--; 1482 } 1483 1484 if (pSignatureEntity->setKey(ouId, m_bIsExporting)) 1485 { 1486 nRefNum--; 1487 } 1488 } 1489 1490 if (nRefNum>0) 1491 { 1492 int nKeeperId; 1493 1494 if (ouLocalName.equalsAscii(ENCRYPTEDKEY_STR)) 1495 { 1496 nKeeperId = m_xSAXEventKeeper->addSecurityElementCollector( 1497 m_bIsExporting ? 1498 (cssxc::sax::ElementMarkPriority_BEFOREMODIFY): 1499 (cssxc::sax::ElementMarkPriority_AFTERMODIFY), 1500 true); 1501 } 1502 else 1503 { 1504 nKeeperId = m_xSAXEventKeeper->addSecurityElementCollector( 1505 m_bIsExporting? 1506 (cssxc::sax::ElementMarkPriority_AFTERMODIFY): 1507 (cssxc::sax::ElementMarkPriority_BEFOREMODIFY), 1508 false); 1509 } 1510 1511 m_vUnsolvedReferenceURIs.push_back(ouId); 1512 m_vUnsolvedReferenceKeeperIds.push_back(nKeeperId); 1513 m_vUnsolvedReferenceRefNums.push_back(nRefNum); 1514 } 1515 } 1516 } 1517 1518 void XSecTester::endMission() 1519 { 1520 while (m_vSignatureList.size() > 0) 1521 { 1522 if (m_vSignatureList.size()>0) 1523 { 1524 SignatureEntity * pSignatureEntity = m_vSignatureList.at(0); 1525 m_vSignatureList.erase(m_vSignatureList.begin()); 1526 pSignatureEntity->endMission(); 1527 delete pSignatureEntity; 1528 } 1529 } 1530 1531 while (m_vUnsolvedReferenceURIs.size()>0) 1532 { 1533 int nKeeperId = m_vUnsolvedReferenceKeeperIds.at(0); 1534 m_xSAXEventKeeper->removeElementCollector(nKeeperId); 1535 m_vUnsolvedReferenceURIs.erase(m_vUnsolvedReferenceURIs.begin()); 1536 m_vUnsolvedReferenceKeeperIds.erase(m_vUnsolvedReferenceKeeperIds.begin()); 1537 m_vUnsolvedReferenceRefNums.erase(m_vUnsolvedReferenceRefNums.begin()); 1538 } 1539 } 1540 1541 void XSecTester::addStartAncestorEvent( 1542 const rtl::OUString& ouName, 1543 const cssu::Reference< cssxs::XAttributeList >& xAttribs) 1544 { 1545 sal_Int32 nLength = xAttribs->getLength(); 1546 AncestorEvent* ancestorEvent = new AncestorEvent( nLength ); 1547 1548 ancestorEvent->bIsStartElement = true; 1549 ancestorEvent->ouName = ouName; 1550 1551 for (int i = 0; i<nLength; ++i) 1552 { 1553 (ancestorEvent->aAttributeList[i]).sName = xAttribs->getNameByIndex((short)i); 1554 (ancestorEvent->aAttributeList[i]).sValue =xAttribs->getValueByIndex((short)i); 1555 } 1556 1557 m_vAncestorEvents.push_back(ancestorEvent); 1558 } 1559 1560 void XSecTester::addEndAncestorEvent(const rtl::OUString& ouName) 1561 { 1562 AncestorEvent* ancestorEvent = new AncestorEvent(0); 1563 1564 ancestorEvent->bIsStartElement = false; 1565 ancestorEvent->ouName = ouName; 1566 1567 m_vAncestorEvents.push_back(ancestorEvent); 1568 } 1569 1570 void XSecTester::sendAncestorStartElementEvent( 1571 const rtl::OUString& ouName, 1572 const cssu::Sequence< cssxcsax::XMLAttribute >& attrList, 1573 const cssu::Reference< cssxs::XDocumentHandler >& xDocumentHandler) const 1574 { 1575 SvXMLAttributeList* pAttributeList = new SvXMLAttributeList(); 1576 cssu::Reference < cssxs::XAttributeList > xAttrList 1577 = cssu::Reference< cssxs::XAttributeList > (pAttributeList); 1578 1579 sal_Int32 nLength = attrList.getLength(); 1580 1581 for (int i = 0; i<nLength; ++i) 1582 { 1583 pAttributeList->AddAttribute( attrList[i].sName, attrList[i].sValue); 1584 } 1585 1586 xDocumentHandler->startElement(ouName, xAttrList); 1587 } 1588 1589 void XSecTester::sendAncestorEndElementEvent( 1590 const rtl::OUString& ouName, 1591 const cssu::Reference< cssxs::XDocumentHandler >& xDocumentHandler) const 1592 { 1593 xDocumentHandler->endElement(ouName); 1594 } 1595 1596 std::vector< AncestorEvent* >::const_iterator XSecTester::checkAncestorStartElementEvent( 1597 const std::vector< AncestorEvent* >::const_iterator& ii, 1598 const cssu::Reference< cssxs::XDocumentHandler >& xDocumentHandler) const 1599 { 1600 std::vector< AncestorEvent* >::const_iterator next = ii+1; 1601 1602 if (next == m_vAncestorEvents.end()) 1603 { 1604 sendAncestorStartElementEvent( 1605 (*ii)->ouName, (*ii)->aAttributeList, xDocumentHandler); 1606 } 1607 else 1608 { 1609 while ((next != m_vAncestorEvents.end()) && ((*next)->bIsStartElement)) 1610 { 1611 next = checkAncestorStartElementEvent(next, xDocumentHandler); 1612 } 1613 1614 if (next != m_vAncestorEvents.end()) 1615 { 1616 next++; 1617 } 1618 } 1619 1620 return next; 1621 } 1622 1623 void XSecTester::flushAncestorEvents( 1624 const cssu::Reference< cssxs::XDocumentHandler >& xDocumentHandler) 1625 { 1626 std::vector< AncestorEvent* >::const_iterator ii; 1627 1628 if (xDocumentHandler != NULL) 1629 { 1630 ii = m_vAncestorEvents.begin(); 1631 1632 while (ii != m_vAncestorEvents.end()) 1633 { 1634 AncestorEvent* ancestorEvent = *ii; 1635 1636 if (ancestorEvent->bIsStartElement) 1637 { 1638 ii = checkAncestorStartElementEvent(ii, xDocumentHandler); 1639 } 1640 else 1641 { 1642 sendAncestorEndElementEvent((*ii)->ouName, xDocumentHandler); 1643 ii++; 1644 } 1645 } 1646 } 1647 1648 /* free the ancestor events list */ 1649 std::vector< AncestorEvent* >::iterator jj; 1650 1651 while (m_vAncestorEvents.size()>0) 1652 { 1653 jj = m_vAncestorEvents.begin(); 1654 delete *jj; 1655 m_vAncestorEvents.erase(jj); 1656 } 1657 } 1658 1659 /* 1660 * Get the length of a file in a platform independant fashion 1661 */ 1662 int getLength(const char *pInputFileName) 1663 { 1664 int nSize = 0; 1665 std::ifstream data(pInputFileName); 1666 1667 data.seekg(0, std::ios_base::end); 1668 nSize = data.tellg(); 1669 1670 return nSize; 1671 } 1672 1673 void outputHeader() 1674 { 1675 fprintf(stderr, "%16s%4s%8s%12s%12s%12s%12s\n", "File Name", "E/I", "Size", "-C++", "-Java", "Forw-O", "No S/E"); 1676 fprintf(stderr, "===============================================================================\n"); 1677 } 1678 1679 /* 1680 * print the output on the screen as well as in the GNUPlot data file 1681 */ 1682 void output(const rtl::OUString& ouInputFileName, 1683 const rtl::OUString& ouTime_C, 1684 const rtl::OUString& ouTime_Java, 1685 const rtl::OUString& ouTime_NoSecurity, 1686 const rtl::OUString& ouTime_JavaForwardOnly, 1687 const rtl::OUString& ouRemark_C, 1688 const rtl::OUString& ouRemark_Java, 1689 bool bIsExporting) 1690 { 1691 int nSize = getLength(rtl::OString(ouInputFileName, ouInputFileName.getLength(), RTL_TEXTENCODING_ASCII_US).getStr()); 1692 std::ofstream data; 1693 1694 /* print screen */ 1695 int nPosition = ouInputFileName.lastIndexOf('\\'); 1696 rtl::OUString fileName = ouInputFileName.copy(nPosition + 1); 1697 1698 fprintf(stderr, "%16s", rtl::OString(fileName, fileName.getLength(), RTL_TEXTENCODING_ASCII_US).getStr()); 1699 1700 fprintf(stderr, "%4s", bIsExporting?"E":"I"); 1701 fprintf(stderr, "%7dK", nSize/1024); 1702 fprintf(stderr, "%8s %3s", 1703 rtl::OString(ouTime_C, ouTime_C.getLength(), RTL_TEXTENCODING_ASCII_US).getStr(), 1704 rtl::OString(ouRemark_C, ouRemark_C.getLength(), RTL_TEXTENCODING_ASCII_US).getStr()); 1705 fprintf(stderr, "%8s %3s", 1706 rtl::OString(ouTime_Java, ouTime_Java.getLength(), RTL_TEXTENCODING_ASCII_US).getStr(), 1707 rtl::OString(ouRemark_Java, ouRemark_Java.getLength(), RTL_TEXTENCODING_ASCII_US).getStr()); 1708 fprintf(stderr, "%12s", rtl::OString(ouTime_JavaForwardOnly, ouTime_JavaForwardOnly.getLength(), RTL_TEXTENCODING_ASCII_US).getStr()); 1709 fprintf(stderr, "%12s", rtl::OString(ouTime_NoSecurity, ouTime_NoSecurity.getLength(), RTL_TEXTENCODING_ASCII_US).getStr()); 1710 fprintf(stderr, "\n"); 1711 1712 /* output the data as GNUPlot data file */ 1713 /* 1714 char str[32]; 1715 sprintf(str, "%d %s", nSize, rtl::OString(ouTime_C, ouTime_C.getLength(), RTL_TEXTENCODING_ASCII_US).getStr()); 1716 data.open("d:\\time_vs_size.txt", std::ios::app); 1717 data << str << std::endl; 1718 data.close(); 1719 1720 sprintf(str, "%d %s", nSize, rtl::OString(ouTime_Java, ouTime_Java.getLength(), RTL_TEXTENCODING_ASCII_US).getStr()); 1721 data.open("d:\\time_vs_size_without_sec.txt", std::ios::app); 1722 data << str << std::endl; 1723 data.close(); 1724 */ 1725 } 1726 1727 int main( int argc, char **argv ) 1728 { 1729 if (argc < 3) 1730 { 1731 fprintf(stderr, "Usage: testtool <exportbatchfile> <importbatchfile> [<cppcryptotoken>] [<javacryptotoken>]\n"); 1732 exit (-1); 1733 } 1734 1735 rtl::OUString aExportBatchFile = rtl::OUString::createFromAscii(argv[1]); 1736 rtl::OUString aImportBatchFile = rtl::OUString::createFromAscii(argv[2]); 1737 rtl::OUString aCPPCryptoToken; 1738 if ( argc > 3 ) 1739 aCPPCryptoToken = rtl::OUString::createFromAscii(argv[3]); 1740 rtl::OUString aJavaCryptoToken; 1741 if ( argc > 4 ) 1742 aJavaCryptoToken = rtl::OUString::createFromAscii(argv[4]); 1743 1744 try 1745 { 1746 uno::Reference< lang::XMultiServiceFactory > xMSF = CreateDemoServiceFactory(); 1747 1748 XSecTester* pTester = new XSecTester( xMSF ); 1749 uno::Reference< xml::sax::XDocumentHandler > xKeepARef = pTester; 1750 1751 pTester->setCryptoDir( aJavaCryptoToken, aCPPCryptoToken ); 1752 1753 rtl::OUString ouTime_C, ouTime_Java, ouTime_NoSecurity, ouTime_JavaForwardOnly; 1754 rtl::OUString ouInputFileName; 1755 rtl::OUString outputFileName1; 1756 rtl::OUString outputFileName2; 1757 rtl::OUString ouRemark_C, ouRemark_Java; 1758 1759 outputHeader(); 1760 1761 std::ifstream batch_export, batch_import; 1762 1763 batch_export.open(OUStringToOString( aExportBatchFile, RTL_TEXTENCODING_ASCII_US ).getStr()); 1764 1765 const int MAX_LINE = 80; 1766 char line[MAX_LINE + 1]; 1767 1768 while (batch_export.getline(line, MAX_LINE)) 1769 { 1770 ouInputFileName = rtl::OUString::createFromAscii(line); 1771 int nPosition = ouInputFileName.lastIndexOf('.'); 1772 int nPosition1; 1773 1774 /* 1775 * export the file with signautre/encryption (C++) 1776 */ 1777 outputFileName1 = ouInputFileName.copy(0, nPosition) + 1778 rtl::OUString::createFromAscii("-ex.xml"); 1779 ouTime_C = pTester->export_xml(ouInputFileName, outputFileName1, sal_False); 1780 nPosition1 = ouTime_C.lastIndexOf('\t'); 1781 ouRemark_C = ouTime_C.copy(nPosition1 + 1); 1782 ouTime_C = ouTime_C.copy(0, nPosition1); 1783 1784 /* 1785 * export the file with signautre/encryption (Java) 1786 */ 1787 outputFileName1 = ouInputFileName.copy(0, nPosition) + 1788 rtl::OUString::createFromAscii("-ex2.xml"); 1789 ouTime_Java = pTester->export_xml(ouInputFileName, outputFileName1, sal_True); 1790 nPosition1 = ouTime_Java.lastIndexOf('\t'); 1791 ouRemark_Java = ouTime_Java.copy(nPosition1 + 1); 1792 ouTime_Java = ouTime_Java.copy(0, nPosition1); 1793 1794 /* 1795 * export the file without signautre/encryption 1796 */ 1797 outputFileName2 = ouInputFileName.copy(0, nPosition) + 1798 rtl::OUString::createFromAscii("-ex-no.xml"); 1799 ouTime_NoSecurity = pTester->transfer_without_sec(ouInputFileName, outputFileName2, sal_False); 1800 1801 /* 1802 * export the file with Java Flat Filter 1803 */ 1804 outputFileName2 = ouInputFileName.copy(0, nPosition) + 1805 rtl::OUString::createFromAscii("-ex-jf.xml"); 1806 ouTime_JavaForwardOnly = pTester->transfer_without_sec(ouInputFileName, outputFileName2, sal_True); 1807 1808 /* 1809 * print output 1810 */ 1811 output(ouInputFileName, ouTime_C, ouTime_Java, ouTime_NoSecurity, ouTime_JavaForwardOnly, ouRemark_C, ouRemark_Java, true); 1812 } 1813 1814 batch_export.close(); 1815 1816 batch_import.open(OUStringToOString( aImportBatchFile, RTL_TEXTENCODING_ASCII_US ).getStr()); 1817 1818 while (batch_import.getline(line, MAX_LINE)) 1819 { 1820 ouInputFileName = rtl::OUString::createFromAscii(line); 1821 int nPosition = ouInputFileName.lastIndexOf('.'); 1822 int nPosition1; 1823 1824 /* 1825 * import the file with signautre/encryption (C++) 1826 */ 1827 outputFileName1 = ouInputFileName.copy(0, nPosition) + 1828 rtl::OUString::createFromAscii("-im.xml"); 1829 ouTime_C = pTester->import_xml(ouInputFileName, outputFileName1, sal_False); 1830 nPosition1 = ouTime_C.lastIndexOf('\t'); 1831 ouRemark_C = ouTime_C.copy(nPosition1 + 1); 1832 ouTime_C = ouTime_C.copy(0, nPosition1); 1833 1834 /* 1835 * import the file with signautre/encryption (Java) 1836 */ 1837 outputFileName1 = ouInputFileName.copy(0, nPosition) + 1838 rtl::OUString::createFromAscii("-im2.xml"); 1839 ouTime_Java = pTester->import_xml(ouInputFileName, outputFileName1, sal_True); 1840 nPosition1 = ouTime_Java.lastIndexOf('\t'); 1841 ouRemark_Java = ouTime_Java.copy(nPosition1 + 1); 1842 ouTime_Java = ouTime_Java.copy(0, nPosition1); 1843 1844 /* 1845 * import the file without signautre/encryption 1846 */ 1847 outputFileName2 = ouInputFileName.copy(0, nPosition) + 1848 rtl::OUString::createFromAscii("-im-no.xml"); 1849 ouTime_NoSecurity = pTester->transfer_without_sec(ouInputFileName, outputFileName2, sal_False); 1850 1851 /* 1852 * import the file without signautre/encryption 1853 */ 1854 1855 outputFileName2 = ouInputFileName.copy(0, nPosition) + 1856 rtl::OUString::createFromAscii("-im-jf.xml"); 1857 ouTime_JavaForwardOnly = pTester->transfer_without_sec(ouInputFileName, outputFileName2, sal_True); 1858 1859 /* 1860 * print output 1861 */ 1862 output(ouInputFileName, ouTime_C, ouTime_Java, ouTime_NoSecurity, ouTime_JavaForwardOnly, ouRemark_C, ouRemark_Java, false); 1863 } 1864 1865 batch_import.close(); 1866 1867 fprintf(stderr, "\n"); 1868 } 1869 catch( cssu::Exception& e ) 1870 { 1871 fprintf( stderr , "\nEXCEPTION! Error Message: %s\n" , 1872 rtl::OUStringToOString( e.Message, RTL_TEXTENCODING_ASCII_US ).getStr() ) ; 1873 } 1874 1875 return 0; 1876 } 1877