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 26 #include "precompiled_xmlsecurity.hxx" 27 28 #include <documentdigitalsignatures.hxx> 29 #include <xmlsecurity/digitalsignaturesdialog.hxx> 30 #include <xmlsecurity/certificateviewer.hxx> 31 #include <xmlsecurity/macrosecurity.hxx> 32 #include <xmlsecurity/biginteger.hxx> 33 #include <xmlsecurity/global.hrc> 34 35 #include <xmloff/xmluconv.hxx> 36 37 #include <../dialogs/resourcemanager.hxx> 38 #include <com/sun/star/embed/XStorage.hpp> 39 #include <com/sun/star/embed/XTransactedObject.hpp> 40 #include <com/sun/star/embed/ElementModes.hpp> 41 #include <com/sun/star/ucb/XContent.hpp> 42 #include <com/sun/star/ucb/XContentProvider.hpp> 43 #include <com/sun/star/ucb/XContentIdentifierFactory.hpp> 44 #include <com/sun/star/ucb/XCommandEnvironment.hpp> 45 #include <com/sun/star/ucb/XCommandProcessor.hpp> 46 #include <com/sun/star/ucb/Command.hpp> 47 #include <tools/urlobj.hxx> 48 #include <vcl/msgbox.hxx> 49 #include <unotools/securityoptions.hxx> 50 #include <com/sun/star/security/CertificateValidity.hpp> 51 #include <com/sun/star/security/SerialNumberAdapter.hpp> 52 #include <ucbhelper/contentbroker.hxx> 53 #include <unotools/ucbhelper.hxx> 54 #include <comphelper/componentcontext.hxx> 55 #include "comphelper/documentconstants.hxx" 56 57 #include "com/sun/star/lang/IllegalArgumentException.hpp" 58 59 #include <stdio.h> 60 61 62 using namespace ::com::sun::star; 63 using namespace ::com::sun::star::uno; 64 namespace css = ::com::sun::star; 65 66 #define OUSTR(x) ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(x) ) 67 68 DocumentDigitalSignatures::DocumentDigitalSignatures( const Reference< XComponentContext >& rxCtx ): 69 mxCtx(rxCtx), 70 m_sODFVersion(ODFVER_012_TEXT), 71 m_nArgumentsCount(0), 72 m_bHasDocumentSignature(false) 73 { 74 } 75 76 void DocumentDigitalSignatures::initialize( const Sequence< Any >& aArguments) 77 throw (css::uno::Exception, css::uno::RuntimeException) 78 { 79 if (aArguments.getLength() == 0 || aArguments.getLength() > 2) 80 throw css::lang::IllegalArgumentException( 81 OUSTR("DocumentDigitalSignatures::initialize requires one or two arguments"), 82 Reference<XInterface>(static_cast<XInitialization*>(this), UNO_QUERY), 0); 83 84 m_nArgumentsCount = aArguments.getLength(); 85 86 if (!(aArguments[0] >>= m_sODFVersion)) 87 throw css::lang::IllegalArgumentException( 88 OUSTR("DocumentDigitalSignatures::initialize: the first arguments must be a string"), 89 Reference<XInterface>(static_cast<XInitialization*>(this), UNO_QUERY), 0); 90 91 if (aArguments.getLength() == 2 92 && !(aArguments[1] >>= m_bHasDocumentSignature)) 93 throw css::lang::IllegalArgumentException( 94 OUSTR("DocumentDigitalSignatures::initialize: the second arguments must be a bool"), 95 Reference<XInterface>(static_cast<XInitialization*>(this), UNO_QUERY), 1); 96 97 //the Version is supported as of ODF1.2, so for and 1.1 document or older we will receive the 98 //an empty string. In this case we set it to ODFVER_010_TEXT. Then we can later check easily 99 //if initialize was called. Only then m_sODFVersion.getLength() is greater than 0 100 if (m_sODFVersion.getLength() == 0) 101 m_sODFVersion = ODFVER_010_TEXT; 102 } 103 104 sal_Bool DocumentDigitalSignatures::signDocumentContent( 105 const Reference< css::embed::XStorage >& rxStorage, 106 const Reference< css::io::XStream >& xSignStream) 107 throw (RuntimeException) 108 { 109 OSL_ENSURE(m_sODFVersion.getLength(), "DocumentDigitalSignatures: ODF Version not set, assuming minimum 1.2"); 110 return ImplViewSignatures( rxStorage, xSignStream, SignatureModeDocumentContent, false ); 111 } 112 113 Sequence< css::security::DocumentSignatureInformation > 114 DocumentDigitalSignatures::verifyDocumentContentSignatures( 115 const Reference< css::embed::XStorage >& rxStorage, 116 const Reference< css::io::XInputStream >& xSignInStream ) throw (RuntimeException) 117 { 118 OSL_ENSURE(m_sODFVersion.getLength(),"DocumentDigitalSignatures: ODF Version not set, assuming minimum 1.2"); 119 return ImplVerifySignatures( rxStorage, xSignInStream, SignatureModeDocumentContent ); 120 } 121 122 void DocumentDigitalSignatures::showDocumentContentSignatures( 123 const Reference< css::embed::XStorage >& rxStorage, 124 const Reference< css::io::XInputStream >& xSignInStream ) throw (RuntimeException) 125 { 126 OSL_ENSURE(m_sODFVersion.getLength(),"DocumentDigitalSignatures: ODF Version not set, assuming minimum 1.2"); 127 ImplViewSignatures( rxStorage, xSignInStream, SignatureModeDocumentContent, true ); 128 } 129 130 ::rtl::OUString DocumentDigitalSignatures::getDocumentContentSignatureDefaultStreamName() 131 throw (css::uno::RuntimeException) 132 { 133 return DocumentSignatureHelper::GetDocumentContentSignatureDefaultStreamName(); 134 } 135 136 sal_Bool DocumentDigitalSignatures::signScriptingContent( 137 const Reference< css::embed::XStorage >& rxStorage, 138 const Reference< css::io::XStream >& xSignStream ) throw (RuntimeException) 139 { 140 OSL_ENSURE(m_sODFVersion.getLength(),"DocumentDigitalSignatures: ODF Version not set, assuming minimum 1.2"); 141 OSL_ENSURE(m_nArgumentsCount == 2, "DocumentDigitalSignatures: Service was not initialized properly"); 142 return ImplViewSignatures( rxStorage, xSignStream, SignatureModeMacros, false ); 143 } 144 145 Sequence< css::security::DocumentSignatureInformation > 146 DocumentDigitalSignatures::verifyScriptingContentSignatures( 147 const Reference< css::embed::XStorage >& rxStorage, 148 const Reference< css::io::XInputStream >& xSignInStream ) throw (RuntimeException) 149 { 150 OSL_ENSURE(m_sODFVersion.getLength(),"DocumentDigitalSignatures: ODF Version not set, assuming minimum 1.2"); 151 return ImplVerifySignatures( rxStorage, xSignInStream, SignatureModeMacros ); 152 } 153 154 void DocumentDigitalSignatures::showScriptingContentSignatures( 155 const Reference< css::embed::XStorage >& rxStorage, 156 const Reference< css::io::XInputStream >& xSignInStream ) throw (RuntimeException) 157 { 158 OSL_ENSURE(m_sODFVersion.getLength(),"DocumentDigitalSignatures: ODF Version not set, assuming minimum 1.2"); 159 ImplViewSignatures( rxStorage, xSignInStream, SignatureModeMacros, true ); 160 } 161 162 ::rtl::OUString DocumentDigitalSignatures::getScriptingContentSignatureDefaultStreamName() 163 throw (css::uno::RuntimeException) 164 { 165 return DocumentSignatureHelper::GetScriptingContentSignatureDefaultStreamName(); 166 } 167 168 169 sal_Bool DocumentDigitalSignatures::signPackage( 170 const Reference< css::embed::XStorage >& rxStorage, 171 const Reference< css::io::XStream >& xSignStream ) throw (RuntimeException) 172 { 173 OSL_ENSURE(m_sODFVersion.getLength(),"DocumentDigitalSignatures: ODF Version not set, assuming minimum 1.2"); 174 return ImplViewSignatures( rxStorage, xSignStream, SignatureModePackage, false ); 175 } 176 177 Sequence< css::security::DocumentSignatureInformation > 178 DocumentDigitalSignatures::verifyPackageSignatures( 179 const Reference< css::embed::XStorage >& rxStorage, 180 const Reference< css::io::XInputStream >& xSignInStream ) throw (RuntimeException) 181 { 182 OSL_ENSURE(m_sODFVersion.getLength(),"DocumentDigitalSignatures: ODF Version not set, assuming minimum 1.2"); 183 return ImplVerifySignatures( rxStorage, xSignInStream, SignatureModePackage ); 184 } 185 186 void DocumentDigitalSignatures::showPackageSignatures( 187 const Reference< css::embed::XStorage >& rxStorage, 188 const Reference< css::io::XInputStream >& xSignInStream ) throw (RuntimeException) 189 { 190 OSL_ENSURE(m_sODFVersion.getLength(),"DocumentDigitalSignatures: ODF Version not set, assuming minimum 1.2"); 191 ImplViewSignatures( rxStorage, xSignInStream, SignatureModePackage, true ); 192 } 193 194 ::rtl::OUString DocumentDigitalSignatures::getPackageSignatureDefaultStreamName( ) 195 throw (::com::sun::star::uno::RuntimeException) 196 { 197 return DocumentSignatureHelper::GetPackageSignatureDefaultStreamName(); 198 } 199 200 201 sal_Bool DocumentDigitalSignatures::ImplViewSignatures( 202 const Reference< css::embed::XStorage >& rxStorage, 203 const Reference< css::io::XInputStream >& xSignStream, 204 DocumentSignatureMode eMode, bool bReadOnly ) throw (RuntimeException) 205 { 206 Reference< io::XStream > xStream; 207 if ( xSignStream.is() ) 208 xStream = Reference< io::XStream >( xSignStream, UNO_QUERY ); 209 return ImplViewSignatures( rxStorage, xStream, eMode, bReadOnly ); 210 } 211 212 sal_Bool DocumentDigitalSignatures::ImplViewSignatures( 213 const Reference< css::embed::XStorage >& rxStorage, const Reference< css::io::XStream >& xSignStream, 214 DocumentSignatureMode eMode, bool bReadOnly ) throw (RuntimeException) 215 { 216 sal_Bool bChanges = sal_False; 217 DigitalSignaturesDialog aSignaturesDialog( 218 NULL, mxCtx, eMode, bReadOnly, m_sODFVersion, m_bHasDocumentSignature); 219 bool bInit = aSignaturesDialog.Init(); 220 DBG_ASSERT( bInit, "Error initializing security context!" ); 221 if ( bInit ) 222 { 223 aSignaturesDialog.SetStorage( rxStorage ); 224 aSignaturesDialog.SetSignatureStream( xSignStream ); 225 if ( aSignaturesDialog.Execute() ) 226 { 227 if ( aSignaturesDialog.SignaturesChanged() ) 228 { 229 bChanges = sal_True; 230 // If we have a storage and no stream, we are responsible for commit 231 if ( rxStorage.is() && !xSignStream.is() ) 232 { 233 uno::Reference< embed::XTransactedObject > xTrans( rxStorage, uno::UNO_QUERY ); 234 xTrans->commit(); 235 } 236 } 237 } 238 } 239 else 240 { 241 WarningBox aBox( NULL, XMLSEC_RES( RID_XMLSECWB_NO_MOZILLA_PROFILE ) ); 242 aBox.Execute(); 243 } 244 245 return bChanges; 246 } 247 248 Sequence< css::security::DocumentSignatureInformation > 249 DocumentDigitalSignatures::ImplVerifySignatures( 250 const Reference< css::embed::XStorage >& rxStorage, 251 const Reference< css::io::XInputStream >& xSignStream, DocumentSignatureMode eMode ) throw (RuntimeException) 252 { 253 if (!rxStorage.is()) 254 { 255 DBG_ASSERT(0, "Error, no XStorage provided"); 256 return Sequence<css::security::DocumentSignatureInformation>(); 257 } 258 // First check for the InputStream, to avoid unnecessary initialization of the security environemnt... 259 SignatureStreamHelper aStreamHelper; 260 Reference< io::XInputStream > xInputStream = xSignStream; 261 262 if ( !xInputStream.is() ) 263 { 264 aStreamHelper = DocumentSignatureHelper::OpenSignatureStream( rxStorage, embed::ElementModes::READ, eMode ); 265 if ( aStreamHelper.xSignatureStream.is() ) 266 xInputStream = Reference< io::XInputStream >( aStreamHelper.xSignatureStream, UNO_QUERY ); 267 } 268 269 if ( !xInputStream.is() ) 270 return Sequence< ::com::sun::star::security::DocumentSignatureInformation >(0); 271 272 273 XMLSignatureHelper aSignatureHelper( mxCtx ); 274 275 bool bInit = aSignatureHelper.Init(); 276 277 DBG_ASSERT( bInit, "Error initializing security context!" ); 278 279 if ( !bInit ) 280 return Sequence< ::com::sun::star::security::DocumentSignatureInformation >(0); 281 282 aSignatureHelper.SetStorage(rxStorage, m_sODFVersion); 283 284 aSignatureHelper.StartMission(); 285 286 aSignatureHelper.ReadAndVerifySignature( xInputStream ); 287 288 aSignatureHelper.EndMission(); 289 290 Reference< ::com::sun::star::xml::crypto::XSecurityEnvironment > xSecEnv = aSignatureHelper.GetSecurityEnvironment(); 291 292 SignatureInformations aSignInfos = aSignatureHelper.GetSignatureInformations(); 293 int nInfos = aSignInfos.size(); 294 Sequence< css::security::DocumentSignatureInformation > aInfos(nInfos); 295 css::security::DocumentSignatureInformation* arInfos = aInfos.getArray(); 296 297 if ( nInfos ) 298 { 299 Reference<security::XSerialNumberAdapter> xSerialNumberAdapter = 300 ::com::sun::star::security::SerialNumberAdapter::create(mxCtx); 301 302 for( int n = 0; n < nInfos; ++n ) 303 { 304 DocumentSignatureAlgorithm mode = DocumentSignatureHelper::getDocumentAlgorithm( 305 m_sODFVersion, aSignInfos[n]); 306 const std::vector< rtl::OUString > aElementsToBeVerified = 307 DocumentSignatureHelper::CreateElementList( 308 rxStorage, ::rtl::OUString(), eMode, mode); 309 310 const SignatureInformation& rInfo = aSignInfos[n]; 311 css::security::DocumentSignatureInformation& rSigInfo = arInfos[n]; 312 313 if (rInfo.ouX509Certificate.getLength()) 314 rSigInfo.Signer = xSecEnv->createCertificateFromAscii( rInfo.ouX509Certificate ) ; 315 if (!rSigInfo.Signer.is()) 316 rSigInfo.Signer = xSecEnv->getCertificate( rInfo.ouX509IssuerName, xSerialNumberAdapter->toSequence( rInfo.ouX509SerialNumber ) ); 317 318 // --> PB 2004-12-14 #i38744# time support again 319 Date aDate( rInfo.stDateTime.Day, rInfo.stDateTime.Month, rInfo.stDateTime.Year ); 320 Time aTime( rInfo.stDateTime.Hours, rInfo.stDateTime.Minutes, 321 rInfo.stDateTime.Seconds, rInfo.stDateTime.HundredthSeconds ); 322 rSigInfo.SignatureDate = aDate.GetDate(); 323 rSigInfo.SignatureTime = aTime.GetTime(); 324 325 // Verify certificate 326 //We have patched our version of libxmlsec, so that it does not verify the certificates. This has two 327 //reasons. First we want two separate status for signature and certificate. Second libxmlsec calls 328 //CERT_VerifyCertificate (solaris, linux) falsly, so that it always regards the certificate as valid. 329 //On Window the checking of the certificate path is buggy. It does name matching (issuer, subject name) 330 //to find the parent certificate. It does not take into account that there can be several certificates 331 //with the same subject name. 332 if (rSigInfo.Signer.is()) 333 { 334 try { 335 rSigInfo.CertificateStatus = xSecEnv->verifyCertificate(rSigInfo.Signer, 336 Sequence<Reference<css::security::XCertificate> >()); 337 } catch (SecurityException& ) { 338 OSL_ENSURE(0, "Verification of certificate failed"); 339 rSigInfo.CertificateStatus = css::security::CertificateValidity::INVALID; 340 } 341 } 342 else 343 { 344 //We should always be aible to get the certificates because it is contained in the document, 345 //unless the document is damaged so that signature xml file could not be parsed. 346 rSigInfo.CertificateStatus = css::security::CertificateValidity::INVALID; 347 } 348 349 rSigInfo.SignatureIsValid = ( rInfo.nStatus == ::com::sun::star::xml::crypto::SecurityOperationStatus_OPERATION_SUCCEEDED ); 350 351 352 if ( rSigInfo.SignatureIsValid ) 353 { 354 rSigInfo.SignatureIsValid = 355 DocumentSignatureHelper::checkIfAllFilesAreSigned( 356 aElementsToBeVerified, rInfo, mode); 357 } 358 if (eMode == SignatureModeDocumentContent) 359 rSigInfo.PartialDocumentSignature = 360 ! DocumentSignatureHelper::isOOo3_2_Signature(aSignInfos[n]); 361 362 } 363 } 364 return aInfos; 365 366 } 367 368 void DocumentDigitalSignatures::manageTrustedSources( ) throw (RuntimeException) 369 { 370 // MT: i45295 371 // SecEnv is only needed to display certificate information from trusted sources. 372 // Macro Security also has some options where no security environment is needed, so raise dialog anyway. 373 // Later I should change the code so the Dialog creates the SecEnv on demand... 374 375 Reference< dcss::xml::crypto::XSecurityEnvironment > xSecEnv; 376 377 XMLSignatureHelper aSignatureHelper( mxCtx ); 378 if ( aSignatureHelper.Init() ) 379 xSecEnv = aSignatureHelper.GetSecurityEnvironment(); 380 381 MacroSecurity aDlg( NULL, mxCtx, xSecEnv ); 382 aDlg.Execute(); 383 } 384 385 void DocumentDigitalSignatures::showCertificate( 386 const Reference< css::security::XCertificate >& _Certificate ) throw (RuntimeException) 387 { 388 XMLSignatureHelper aSignatureHelper( mxCtx ); 389 390 bool bInit = aSignatureHelper.Init(); 391 392 DBG_ASSERT( bInit, "Error initializing security context!" ); 393 394 if ( bInit ) 395 { 396 CertificateViewer aViewer( NULL, aSignatureHelper.GetSecurityEnvironment(), _Certificate, sal_False ); 397 aViewer.Execute(); 398 } 399 400 } 401 402 ::sal_Bool DocumentDigitalSignatures::isAuthorTrusted( 403 const Reference< css::security::XCertificate >& Author ) throw (RuntimeException) 404 { 405 sal_Bool bFound = sal_False; 406 407 Reference<security::XSerialNumberAdapter> xSerialNumberAdapter = 408 ::com::sun::star::security::SerialNumberAdapter::create(mxCtx); 409 410 ::rtl::OUString sSerialNum = xSerialNumberAdapter->toString( Author->getSerialNumber() ); 411 412 Sequence< SvtSecurityOptions::Certificate > aTrustedAuthors = SvtSecurityOptions().GetTrustedAuthors(); 413 const SvtSecurityOptions::Certificate* pAuthors = aTrustedAuthors.getConstArray(); 414 const SvtSecurityOptions::Certificate* pAuthorsEnd = pAuthors + aTrustedAuthors.getLength(); 415 for ( ; pAuthors != pAuthorsEnd; ++pAuthors ) 416 { 417 SvtSecurityOptions::Certificate aAuthor = *pAuthors; 418 if ( ( aAuthor[0] == Author->getIssuerName() ) && ( aAuthor[1] == sSerialNum ) ) 419 { 420 bFound = sal_True; 421 break; 422 } 423 } 424 425 return bFound; 426 } 427 428 ::sal_Bool DocumentDigitalSignatures::isLocationTrusted( const ::rtl::OUString& Location ) throw (RuntimeException) 429 { 430 sal_Bool bFound = sal_False; 431 INetURLObject aLocObj( Location ); 432 INetURLObject aLocObjLowCase( Location.toAsciiLowerCase() ); // will be used for case insensitive comparing 433 434 ::com::sun::star::uno::Reference< ::com::sun::star::ucb::XContentProvider > xContentProvider; 435 ::ucbhelper::ContentBroker* pBroker = NULL; 436 437 //warning free code 438 //if ( aLocObj.GetProtocol() == INET_PROT_FILE && ( pBroker = ::ucbhelper::ContentBroker::get() ) ) 439 // xContentProvider = pBroker->getContentProviderInterface(); 440 if ( aLocObj.GetProtocol() == INET_PROT_FILE) 441 { 442 pBroker = ::ucbhelper::ContentBroker::get(); 443 if (pBroker) 444 xContentProvider = pBroker->getContentProviderInterface(); 445 } 446 447 Sequence< ::rtl::OUString > aSecURLs = SvtSecurityOptions().GetSecureURLs(); 448 const ::rtl::OUString* pSecURLs = aSecURLs.getConstArray(); 449 const ::rtl::OUString* pSecURLsEnd = pSecURLs + aSecURLs.getLength(); 450 for ( ; pSecURLs != pSecURLsEnd && !bFound; ++pSecURLs ) 451 bFound = ::utl::UCBContentHelper::IsSubPath( *pSecURLs, Location, xContentProvider ); 452 453 return bFound; 454 } 455 456 void DocumentDigitalSignatures::addAuthorToTrustedSources( 457 const Reference< css::security::XCertificate >& Author ) throw (RuntimeException) 458 { 459 SvtSecurityOptions aSecOpts; 460 461 Reference<security::XSerialNumberAdapter> xSerialNumberAdapter = 462 ::com::sun::star::security::SerialNumberAdapter::create(mxCtx); 463 464 SvtSecurityOptions::Certificate aNewCert( 3 ); 465 aNewCert[ 0 ] = Author->getIssuerName(); 466 aNewCert[ 1 ] = xSerialNumberAdapter->toString( Author->getSerialNumber() ); 467 468 rtl::OUStringBuffer aStrBuffer; 469 SvXMLUnitConverter::encodeBase64(aStrBuffer, Author->getEncoded()); 470 aNewCert[ 2 ] = aStrBuffer.makeStringAndClear(); 471 472 473 Sequence< SvtSecurityOptions::Certificate > aTrustedAuthors = aSecOpts.GetTrustedAuthors(); 474 sal_Int32 nCnt = aTrustedAuthors.getLength(); 475 aTrustedAuthors.realloc( nCnt + 1 ); 476 aTrustedAuthors[ nCnt ] = aNewCert; 477 478 aSecOpts.SetTrustedAuthors( aTrustedAuthors ); 479 } 480 481 void DocumentDigitalSignatures::addLocationToTrustedSources( const ::rtl::OUString& Location ) throw (RuntimeException) 482 { 483 SvtSecurityOptions aSecOpt; 484 485 Sequence< ::rtl::OUString > aSecURLs = aSecOpt.GetSecureURLs(); 486 sal_Int32 nCnt = aSecURLs.getLength(); 487 aSecURLs.realloc( nCnt + 1 ); 488 aSecURLs[ nCnt ] = Location; 489 490 aSecOpt.SetSecureURLs( aSecURLs ); 491 } 492 493 rtl::OUString DocumentDigitalSignatures::GetImplementationName() throw (RuntimeException) 494 { 495 return rtl::OUString ( RTL_CONSTASCII_USTRINGPARAM ( "com.sun.star.security.DocumentDigitalSignatures" ) ); 496 } 497 498 Sequence< rtl::OUString > DocumentDigitalSignatures::GetSupportedServiceNames() throw (cssu::RuntimeException) 499 { 500 Sequence < rtl::OUString > aRet(1); 501 rtl::OUString* pArray = aRet.getArray(); 502 pArray[0] = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( "com.sun.star.security.DocumentDigitalSignatures" ) ); 503 return aRet; 504 } 505 506 507 Reference< XInterface > DocumentDigitalSignatures_CreateInstance( 508 const Reference< XComponentContext >& rCtx) throw ( Exception ) 509 { 510 return (cppu::OWeakObject*) new DocumentDigitalSignatures( rCtx ); 511 } 512 513