sfx2/source/doc/docmacromode.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <config_features.h>
  21
  22 #include <sfx2/docmacromode.hxx>
  23 #include <sfx2/signaturestate.hxx>
  24 #include <sfx2/docfile.hxx>
  25
  26 #include <com/sun/star/document/MacroExecMode.hpp>
  27 #include <com/sun/star/task/ErrorCodeRequest.hpp>
  28 #include <com/sun/star/task/DocumentMacroConfirmationRequest.hpp>
  29 #include <com/sun/star/security/DocumentDigitalSignatures.hpp>
  30 #include <com/sun/star/script/XLibraryContainer.hpp>
  31 #include <com/sun/star/document/XEmbeddedScripts.hpp>
  32
  33 #include <comphelper/processfactory.hxx>
  34 #include <framework/interaction.hxx>
  35 #include <osl/file.hxx>
  36 #include <unotools/securityoptions.hxx>
  37 #include <svtools/sfxecode.hxx>
  38 #include <tools/diagnose_ex.h>
  39 #include <tools/urlobj.hxx>
  40
  41
  42 namespace sfx2
  43 {
  44
  45
  46     using ::com::sun::star::uno::Reference;
  47     using ::com::sun::star::task::XInteractionHandler;
  48     using ::com::sun::star::uno::Any;
  49     using ::com::sun::star::uno::Sequence;
  50     using ::com::sun::star::task::DocumentMacroConfirmationRequest;
  51     using ::com::sun::star::task::ErrorCodeRequest;
  52     using ::com::sun::star::uno::Exception;
  53     using ::com::sun::star::security::DocumentDigitalSignatures;
  54     using ::com::sun::star::security::XDocumentDigitalSignatures;
  55     using ::com::sun::star::embed::XStorage;
  56     using ::com::sun::star::document::XEmbeddedScripts;
  57     using ::com::sun::star::script::XLibraryContainer;
  58     using ::com::sun::star::container::XNameAccess;
  59     using ::com::sun::star::uno::UNO_QUERY_THROW;
  60
  61     namespace MacroExecMode = ::com::sun::star::document::MacroExecMode;
  62
  63
  64     //= DocumentMacroMode_Data
  65
  66     struct DocumentMacroMode_Data
  67     {
  68         IMacroDocumentAccess&       m_rDocumentAccess;
  69         bool                    m_bMacroDisabledMessageShown;
  70         bool                    m_bDocMacroDisabledMessageShown;
  71
  72         explicit DocumentMacroMode_Data( IMacroDocumentAccess& rDocumentAccess )
  73             :m_rDocumentAccess( rDocumentAccess )
  74             ,m_bMacroDisabledMessageShown( false )
  75             ,m_bDocMacroDisabledMessageShown( false )
  76         {
  77         }
  78     };
  79
  80
  81     //= helper
  82
  83     namespace
  84     {
  85
  86         void lcl_showGeneralSfxErrorOnce( const Reference< XInteractionHandler >& rxHandler, ErrCode nSfxErrorCode, bool& rbAlreadyShown )
  87         {
  88             if ( rbAlreadyShown )
  89                 return;
  90
  91             ErrorCodeRequest aErrorCodeRequest;
  92             aErrorCodeRequest.ErrCode = sal_uInt32(nSfxErrorCode);
  93
  94             SfxMedium::CallApproveHandler( rxHandler, makeAny( aErrorCodeRequest ), false );
  95             rbAlreadyShown = true;
  96         }
  97
  98
  99         void lcl_showMacrosDisabledError( const Reference< XInteractionHandler >& rxHandler, bool& rbAlreadyShown )
 100         {
 101             lcl_showGeneralSfxErrorOnce( rxHandler, ERRCODE_SFX_MACROS_SUPPORT_DISABLED, rbAlreadyShown );
 102         }
 103
 104
 105         void lcl_showDocumentMacrosDisabledError( const Reference< XInteractionHandler >& rxHandler, bool& rbAlreadyShown )
 106         {
 107 #ifdef MACOSX
 108             lcl_showGeneralSfxErrorOnce( rxHandler, ERRCODE_SFX_DOCUMENT_MACRO_DISABLED_MAC, rbAlreadyShown );
 109 #else
 110             lcl_showGeneralSfxErrorOnce( rxHandler, ERRCODE_SFX_DOCUMENT_MACRO_DISABLED, rbAlreadyShown );
 111 #endif
 112         }
 113
 114         void lcl_showMacrosDisabledUnsignedContentError( const Reference< XInteractionHandler >& rxHandler, bool& rbAlreadyShown )
 115         {
 116             lcl_showGeneralSfxErrorOnce( rxHandler, ERRCODE_SFX_DOCUMENT_MACRO_DISABLED_CONTENT_UNSIGNED, rbAlreadyShown );
 117         }
 118
 119         bool lcl_showMacroWarning( const Reference< XInteractionHandler >& rxHandler,
 120             const OUString& rDocumentLocation )
 121         {
 122             DocumentMacroConfirmationRequest aRequest;
 123             aRequest.DocumentURL = rDocumentLocation;
 124             return SfxMedium::CallApproveHandler( rxHandler, makeAny( aRequest ), true );
 125         }
 126     }
 127
 128     //= DocumentMacroMode
 129     DocumentMacroMode::DocumentMacroMode( IMacroDocumentAccess& rDocumentAccess )
 130         :m_xData( std::make_shared<DocumentMacroMode_Data>( rDocumentAccess ) ),
 131         m_bNeedsContentSigned(false)
 132     {
 133     }
 134
 135     bool DocumentMacroMode::allowMacroExecution()
 136     {
 137         m_xData->m_rDocumentAccess.setCurrentMacroExecMode( MacroExecMode::ALWAYS_EXECUTE_NO_WARN );
 138         return true;
 139     }
 140
 141     bool DocumentMacroMode::disallowMacroExecution()
 142     {
 143         m_xData->m_rDocumentAccess.setCurrentMacroExecMode( MacroExecMode::NEVER_EXECUTE );
 144         return false;
 145     }
 146
 147     bool DocumentMacroMode::adjustMacroMode( const Reference< XInteractionHandler >& rxInteraction, bool bHasValidContentSignature )
 148     {
 149         sal_uInt16 nMacroExecutionMode = m_xData->m_rDocumentAccess.getCurrentMacroExecMode();
 150
 151         if ( SvtSecurityOptions().IsMacroDisabled() )
 152         {
 153             // no macro should be executed at all
 154             lcl_showMacrosDisabledError( rxInteraction, m_xData->m_bMacroDisabledMessageShown );
 155             return disallowMacroExecution();
 156         }
 157
 158         // get setting from configuration if required
 159         enum AutoConfirmation
 160         {
 161             eNoAutoConfirm,
 162             eAutoConfirmApprove,
 163             eAutoConfirmReject
 164         };
 165         AutoConfirmation eAutoConfirm( eNoAutoConfirm );
 166
 167         if  (   ( nMacroExecutionMode == MacroExecMode::USE_CONFIG )
 168             ||  ( nMacroExecutionMode == MacroExecMode::USE_CONFIG_REJECT_CONFIRMATION )
 169             ||  ( nMacroExecutionMode == MacroExecMode::USE_CONFIG_APPROVE_CONFIRMATION )
 170             )
 171         {
 172             // check confirm first, as nMacroExecutionMode is always overwritten by the GetMacroSecurityLevel() switch
 173             if (nMacroExecutionMode == MacroExecMode::USE_CONFIG_REJECT_CONFIRMATION)
 174                 eAutoConfirm = eAutoConfirmReject;
 175             else if (nMacroExecutionMode == MacroExecMode::USE_CONFIG_APPROVE_CONFIRMATION)
 176                 eAutoConfirm = eAutoConfirmApprove;
 177
 178             SvtSecurityOptions aOpt;
 179             switch ( aOpt.GetMacroSecurityLevel() )
 180             {
 181                 case 3:
 182                     nMacroExecutionMode = MacroExecMode::FROM_LIST_NO_WARN;
 183                     break;
 184                 case 2:
 185                     nMacroExecutionMode = MacroExecMode::FROM_LIST_AND_SIGNED_WARN;
 186                     break;
 187                 case 1:
 188                     nMacroExecutionMode = MacroExecMode::ALWAYS_EXECUTE;
 189                     break;
 190                 case 0:
 191                     nMacroExecutionMode = MacroExecMode::ALWAYS_EXECUTE_NO_WARN;
 192                     break;
 193                 default:
 194                     OSL_FAIL( "DocumentMacroMode::adjustMacroMode: unexpected macro security level!" );
 195                     nMacroExecutionMode = MacroExecMode::NEVER_EXECUTE;
 196             }
 197         }
 198
 199         if ( nMacroExecutionMode == MacroExecMode::NEVER_EXECUTE )
 200             return false;
 201
 202         if ( nMacroExecutionMode == MacroExecMode::ALWAYS_EXECUTE_NO_WARN )
 203             return true;
 204
 205         try
 206         {
 207             // get document location from medium name and check whether it is a trusted one
 208             // the service is created without document version, since it is not of interest here
 209             Reference< XDocumentDigitalSignatures > xSignatures(DocumentDigitalSignatures::createDefault(::comphelper::getProcessComponentContext()));
 210             INetURLObject aURLReferer( m_xData->m_rDocumentAccess.getDocumentLocation() );
 211
 212             OUString aLocation;
 213             if ( aURLReferer.removeSegment() )
 214                 aLocation = aURLReferer.GetMainURL( INetURLObject::DecodeMechanism::NONE );
 215
 216             if ( !aLocation.isEmpty() && xSignatures->isLocationTrusted( aLocation ) )
 217             {
 218                 return allowMacroExecution();
 219             }
 220
 221             // at this point it is clear that the document is not in the secure location
 222             if ( nMacroExecutionMode == MacroExecMode::FROM_LIST_NO_WARN )
 223             {
 224                 lcl_showDocumentMacrosDisabledError( rxInteraction, m_xData->m_bDocMacroDisabledMessageShown );
 225                 return disallowMacroExecution();
 226             }
 227
 228             // check whether the document is signed with trusted certificate
 229             if ( nMacroExecutionMode != MacroExecMode::FROM_LIST )
 230             {
 231                 // the trusted macro check will also retrieve the signature state ( small optimization )
 232                 const SvtSecurityOptions aSecOption;
 233                 const bool bAllowUIToAddAuthor = nMacroExecutionMode != MacroExecMode::FROM_LIST_AND_SIGNED_NO_WARN
 234                                                  && (nMacroExecutionMode == MacroExecMode::ALWAYS_EXECUTE
 235                                                      || !aSecOption.IsReadOnly(SvtSecurityOptions::EOption::MacroTrustedAuthors));
 236                 const bool bHasTrustedMacroSignature = m_xData->m_rDocumentAccess.hasTrustedScriptingSignature(bAllowUIToAddAuthor);
 237
 238                 SignatureState nSignatureState = m_xData->m_rDocumentAccess.getScriptingSignatureState();
 239                 if ( nSignatureState == SignatureState::BROKEN )
 240                 {
 241                     if (!bAllowUIToAddAuthor)
 242                         lcl_showDocumentMacrosDisabledError(rxInteraction, m_xData->m_bDocMacroDisabledMessageShown);
 243                     return disallowMacroExecution();
 244                 }
 245                 else if ( m_xData->m_rDocumentAccess.macroCallsSeenWhileLoading() &&
 246                           bHasTrustedMacroSignature &&
 247                           !bHasValidContentSignature)
 248                 {
 249                     // When macros are signed, and the document has events which call macros, the document content needs to be signed too.
 250                     lcl_showMacrosDisabledUnsignedContentError(rxInteraction, m_xData->m_bDocMacroDisabledMessageShown);
 251                     return disallowMacroExecution();
 252                 }
 253                 else if ( bHasTrustedMacroSignature )
 254                 {
 255                     // there is trusted macro signature, allow macro execution
 256                     return allowMacroExecution();
 257                 }
 258                 else if ( nSignatureState == SignatureState::OK
 259                        || nSignatureState == SignatureState::NOTVALIDATED )
 260                 {
 261                     // there is valid signature, but it is not from the trusted author
 262                     if (!bAllowUIToAddAuthor)
 263                         lcl_showDocumentMacrosDisabledError(rxInteraction, m_xData->m_bDocMacroDisabledMessageShown);
 264                     return disallowMacroExecution();
 265                 }
 266             }
 267
 268             // at this point it is clear that the document is neither in secure location nor signed with trusted certificate
 269             if  (   ( nMacroExecutionMode == MacroExecMode::FROM_LIST_AND_SIGNED_NO_WARN )
 270                 ||  ( nMacroExecutionMode == MacroExecMode::FROM_LIST_AND_SIGNED_WARN )
 271                 )
 272             {
 273                 if  ( nMacroExecutionMode == MacroExecMode::FROM_LIST_AND_SIGNED_WARN )
 274                     lcl_showDocumentMacrosDisabledError( rxInteraction, m_xData->m_bDocMacroDisabledMessageShown );
 275
 276                 return disallowMacroExecution();
 277             }
 278         }
 279         catch ( const Exception& )
 280         {
 281             if  (   ( nMacroExecutionMode == MacroExecMode::FROM_LIST_NO_WARN )
 282                 ||  ( nMacroExecutionMode == MacroExecMode::FROM_LIST_AND_SIGNED_WARN )
 283                 ||  ( nMacroExecutionMode == MacroExecMode::FROM_LIST_AND_SIGNED_NO_WARN )
 284                 )
 285             {
 286                 return disallowMacroExecution();
 287             }
 288         }
 289
 290         // confirmation is required
 291         bool bSecure = false;
 292
 293         if ( eAutoConfirm == eNoAutoConfirm )
 294         {
 295             OUString sReferrer( m_xData->m_rDocumentAccess.getDocumentLocation() );
 296
 297             OUString aSystemFileURL;
 298             if ( osl::FileBase::getSystemPathFromFileURL( sReferrer, aSystemFileURL ) == osl::FileBase::E_None )
 299                 sReferrer = aSystemFileURL;
 300
 301             bSecure = lcl_showMacroWarning( rxInteraction, sReferrer );
 302         }
 303         else
 304             bSecure = ( eAutoConfirm == eAutoConfirmApprove );
 305
 306         return ( bSecure ? allowMacroExecution() : disallowMacroExecution() );
 307     }
 308
 309
 310     bool DocumentMacroMode::isMacroExecutionDisallowed() const
 311     {
 312         return m_xData->m_rDocumentAccess.getCurrentMacroExecMode() == MacroExecMode::NEVER_EXECUTE;
 313     }
 314
 315
 316     bool DocumentMacroMode::containerHasBasicMacros( const Reference< XLibraryContainer >& xContainer )
 317     {
 318         bool bHasMacroLib = false;
 319         try
 320         {
 321             if ( xContainer.is() )
 322             {
 323                 // a library container exists; check if it's empty
 324
 325                 // if there are libraries except the "Standard" library
 326                 // we assume that they are not empty (because they have been created by the user)
 327                 if ( !xContainer->hasElements() )
 328                     bHasMacroLib = false;
 329                 else
 330                 {
 331                     const OUString aStdLibName( "Standard" );
 332                     const OUString aVBAProject( "VBAProject" );
 333                     const Sequence< OUString > aElements = xContainer->getElementNames();
 334                     for( const OUString& aElement : aElements )
 335                     {
 336                         if( aElement == aStdLibName || aElement == aVBAProject )
 337                         {
 338                             Reference < XNameAccess > xLib;
 339                             Any aAny = xContainer->getByName( aElement );
 340                             aAny >>= xLib;
 341                             if ( xLib.is() && xLib->hasElements() )
 342                                 return true;
 343                         }
 344                         else
 345                             return true;
 346                     }
 347                 }
 348             }
 349         }
 350         catch( const Exception& )
 351         {
 352             DBG_UNHANDLED_EXCEPTION("sfx.doc");
 353         }
 354         return bHasMacroLib;
 355     }
 356
 357
 358     bool DocumentMacroMode::hasMacroLibrary() const
 359     {
 360         bool bHasMacroLib = false;
 361 #if HAVE_FEATURE_SCRIPTING
 362         try
 363         {
 364             Reference< XEmbeddedScripts > xScripts( m_xData->m_rDocumentAccess.getEmbeddedDocumentScripts() );
 365             Reference< XLibraryContainer > xContainer;
 366             if ( xScripts.is() )
 367                 xContainer.set( xScripts->getBasicLibraries(), UNO_QUERY_THROW );
 368             bHasMacroLib = containerHasBasicMacros( xContainer );
 369
 370         }
 371         catch( const Exception& )
 372         {
 373             DBG_UNHANDLED_EXCEPTION("sfx.doc");
 374         }
 375 #endif
 376         return bHasMacroLib;
 377     }
 378
 379
 380     bool DocumentMacroMode::storageHasMacros( const Reference< XStorage >& rxStorage )
 381     {
 382         bool bHasMacros = false;
 383         if ( rxStorage.is() )
 384         {
 385             try
 386             {
 387                 const OUString s_sBasicStorageName( OUString::intern( RTL_CONSTASCII_USTRINGPARAM( "Basic" ) ) );
 388                 const OUString s_sScriptsStorageName( OUString::intern( RTL_CONSTASCII_USTRINGPARAM( "Scripts" ) ) );
 389
 390                 bHasMacros =(   (   rxStorage->hasByName( s_sBasicStorageName )
 391                                 &&  rxStorage->isStorageElement( s_sBasicStorageName )
 392                                 )
 393                             ||  (   rxStorage->hasByName( s_sScriptsStorageName )
 394                                 &&  rxStorage->isStorageElement( s_sScriptsStorageName )
 395                                 )
 396                             );
 397             }
 398             catch ( const Exception& )
 399             {
 400                 DBG_UNHANDLED_EXCEPTION("sfx.doc");
 401             }
 402         }
 403         return bHasMacros;
 404     }
 405
 406
 407     bool DocumentMacroMode::checkMacrosOnLoading( const Reference< XInteractionHandler >& rxInteraction, bool bHasValidContentSignature )
 408     {
 409         bool bAllow = false;
 410         if ( SvtSecurityOptions().IsMacroDisabled() )
 411         {
 412             // no macro should be executed at all
 413             bAllow = disallowMacroExecution();
 414         }
 415         else
 416         {
 417             if (m_xData->m_rDocumentAccess.documentStorageHasMacros() || hasMacroLibrary() || m_xData->m_rDocumentAccess.macroCallsSeenWhileLoading())
 418             {
 419                 if (m_xData->m_rDocumentAccess.macroCallsSeenWhileLoading())
 420                     m_bNeedsContentSigned = true;
 421                 bAllow = adjustMacroMode( rxInteraction, bHasValidContentSignature );
 422             }
 423             else if ( !isMacroExecutionDisallowed() )
 424             {
 425                 // if macros will be added by the user later, the security check is obsolete
 426                 bAllow = allowMacroExecution();
 427             }
 428         }
 429         return bAllow;
 430     }
 431
 432
 433 } // namespace sfx2
 434
 435
 436 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */