uui/source/passwordcontainer.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 <comphelper/processfactory.hxx>
  21 #include <cppuhelper/factory.hxx>
  22 #include <cppuhelper/supportsservice.hxx>
  23 #include <osl/diagnose.h>
  24
  25 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  26 #include <com/sun/star/task/NoMasterException.hpp>
  27 #include <com/sun/star/task/PasswordContainer.hpp>
  28 #include <com/sun/star/task/XInteractionHandler2.hpp>
  29 #include <com/sun/star/ucb/AuthenticationRequest.hpp>
  30 #include <com/sun/star/ucb/URLAuthenticationRequest.hpp>
  31 #include <com/sun/star/ucb/XInteractionSupplyAuthentication.hpp>
  32 #include <com/sun/star/ucb/XInteractionSupplyAuthentication2.hpp>
  33 #include <officecfg/Office/Common.hxx>
  34
  35 #include "passwordcontainer.hxx"
  36
  37 using namespace com::sun::star;
  38
  39 namespace {
  40
  41
  42 bool fillContinuation(
  43     bool bUseSystemCredentials,
  44     const ucb::AuthenticationRequest & rRequest,
  45     const task::UrlRecord & aRec,
  46     const uno::Reference< ucb::XInteractionSupplyAuthentication > &
  47         xSupplyAuthentication,
  48     const uno::Reference< ucb::XInteractionSupplyAuthentication2 > &
  49         xSupplyAuthentication2,
  50     bool bCanUseSystemCredentials,
  51     bool bCheckForEqualPasswords )
  52 {
  53     if ( bUseSystemCredentials )
  54     {
  55         // "use system creds" record found.
  56         // Wants client that we use it?
  57         if ( xSupplyAuthentication2.is() && bCanUseSystemCredentials )
  58         {
  59             xSupplyAuthentication2->setUseSystemCredentials( true );
  60             return true;
  61         }
  62         return false;
  63     }
  64     else if (aRec.UserList.getLength() != 0)
  65     {
  66         if (aRec.UserList[0].Passwords.getLength() == 0)
  67         {
  68             // Password sequence can be empty, for instance if master
  69             // password was not given (e.g. master pw dialog canceled)
  70             // pw container does not throw NoMasterException in this case.
  71             // bug???
  72             return false;
  73         }
  74
  75         // "user/pass" record found.
  76         if (!bCheckForEqualPasswords || !rRequest.HasPassword
  77             || rRequest.Password != aRec.UserList[0].Passwords[0]) // failed login attempt?
  78         {
  79             if (xSupplyAuthentication->canSetUserName())
  80                 xSupplyAuthentication->
  81                     setUserName(aRec.UserList[0].UserName);
  82
  83             if (xSupplyAuthentication->canSetPassword())
  84                 xSupplyAuthentication->
  85                     setPassword(aRec.UserList[0].Passwords[0]);
  86             if (aRec.UserList[0].Passwords.getLength() > 1)
  87             {
  88                 if (rRequest.HasRealm)
  89                 {
  90                     if (xSupplyAuthentication->canSetRealm())
  91                         xSupplyAuthentication->
  92                             setRealm(aRec.UserList[0].Passwords[1]);
  93                 }
  94                 else if (xSupplyAuthentication->canSetAccount())
  95                     xSupplyAuthentication->
  96                         setAccount(aRec.UserList[0].Passwords[1]);
  97             }
  98
  99             if ( xSupplyAuthentication2.is() && bCanUseSystemCredentials )
 100                 xSupplyAuthentication2->setUseSystemCredentials( false );
 101
 102             return true;
 103         }
 104     }
 105     return false;
 106 }
 107
 108 } // namespace
 109
 110 namespace uui {
 111
 112
 113 PasswordContainerHelper::PasswordContainerHelper(
 114     uno::Reference< uno::XComponentContext > const & xContext ):
 115     m_xPasswordContainer(task::PasswordContainer::create(xContext))
 116 {}
 117
 118
 119 bool PasswordContainerHelper::handleAuthenticationRequest(
 120     ucb::AuthenticationRequest const & rRequest,
 121     uno::Reference< ucb::XInteractionSupplyAuthentication > const &
 122         xSupplyAuthentication,
 123     OUString const & rURL,
 124     uno::Reference< task::XInteractionHandler2 > const & xIH )
 125 {
 126     uno::Reference< task::XInteractionHandler > xIH1(xIH, uno::UNO_QUERY);
 127
 128     // Is continuation even a XInteractionSupplyAuthentication2, which
 129     // is derived from XInteractionSupplyAuthentication?
 130     uno::Reference< ucb::XInteractionSupplyAuthentication2 >
 131         xSupplyAuthentication2(xSupplyAuthentication, uno::UNO_QUERY);
 132
 133     bool bCanUseSystemCredentials = false;
 134     if (xSupplyAuthentication2.is())
 135     {
 136         sal_Bool bDefaultUseSystemCredentials;
 137         bCanUseSystemCredentials
 138             =  xSupplyAuthentication2->canUseSystemCredentials(
 139                 bDefaultUseSystemCredentials );
 140     }
 141
 142     if ( bCanUseSystemCredentials )
 143     {
 144         // Does the configuration mandate that we try system credentials first?
 145         bool bUseSystemCredentials = ::officecfg::Office::Common::Passwords::TrySystemCredentialsFirst::get();
 146         if (!bUseSystemCredentials)
 147         {
 148             // Runtime / Persistent info avail for current auth request?
 149             OUString aResult = m_xPasswordContainer->findUrl(
 150                 rURL.isEmpty() ? rRequest.ServerName : rURL);
 151             bUseSystemCredentials = !aResult.isEmpty();
 152         }
 153         if ( bUseSystemCredentials )
 154         {
 155             if ( fillContinuation( true,
 156                                    rRequest,
 157                                    task::UrlRecord(),
 158                                    xSupplyAuthentication,
 159                                    xSupplyAuthentication2,
 160                                    bCanUseSystemCredentials,
 161                                    false ) )
 162             {
 163                 return true;
 164             }
 165         }
 166     }
 167
 168     // m_xPasswordContainer works with userName passwdSequences pairs:
 169     if (rRequest.HasUserName && rRequest.HasPassword)
 170     {
 171         try
 172         {
 173             if (rRequest.UserName.isEmpty())
 174             {
 175                 task::UrlRecord aRec;
 176                 if ( !rURL.isEmpty() )
 177                     aRec = m_xPasswordContainer->find(rURL, xIH1);
 178
 179                 if ( aRec.UserList.getLength() == 0 )
 180                 {
 181                     // compat: try server name.
 182                     aRec = m_xPasswordContainer->find(rRequest.ServerName, xIH1);
 183                 }
 184
 185                 if ( fillContinuation( false,
 186                                        rRequest,
 187                                        aRec,
 188                                        xSupplyAuthentication,
 189                                        xSupplyAuthentication2,
 190                                        bCanUseSystemCredentials,
 191                                        false ) )
 192                 {
 193                     return true;
 194                 }
 195             }
 196             else
 197             {
 198                 task::UrlRecord aRec;
 199                 if ( !rURL.isEmpty() )
 200                     aRec = m_xPasswordContainer->findForName(
 201                         rURL, rRequest.UserName, xIH1);
 202
 203                 if ( aRec.UserList.getLength() == 0 )
 204                 {
 205                     // compat: try server name.
 206                     aRec = m_xPasswordContainer->findForName(
 207                         rRequest.ServerName, rRequest.UserName, xIH1);
 208                 }
 209
 210                 if ( fillContinuation( false,
 211                                        rRequest,
 212                                        aRec,
 213                                        xSupplyAuthentication,
 214                                        xSupplyAuthentication2,
 215                                        bCanUseSystemCredentials,
 216                                        true ) )
 217                 {
 218                     return true;
 219                 }
 220             }
 221         }
 222         catch (task::NoMasterException const &)
 223         {} // user did not enter master password
 224     }
 225     return false;
 226 }
 227
 228
 229 bool PasswordContainerHelper::addRecord(
 230     OUString const & rURL,
 231     OUString const & rUsername,
 232     uno::Sequence< OUString > const & rPasswords,
 233     uno::Reference< task::XInteractionHandler2 > const & xIH,
 234     bool bPersist )
 235 {
 236     uno::Reference< task::XInteractionHandler > xIH1(xIH, uno::UNO_QUERY);
 237
 238     try
 239     {
 240         if ( !rUsername.isEmpty() )
 241         {
 242             OSL_ENSURE( m_xPasswordContainer.is(),
 243                         "Got no XPasswordContainer!" );
 244             if ( !m_xPasswordContainer.is() )
 245                 return false;
 246
 247             if ( bPersist )
 248             {
 249                 // If persistent storing of passwords is not yet
 250                 // allowed, enable it.
 251                 if ( !m_xPasswordContainer->isPersistentStoringAllowed() )
 252                     m_xPasswordContainer->allowPersistentStoring( true );
 253
 254                 m_xPasswordContainer->addPersistent( rURL,
 255                                                      rUsername,
 256                                                      rPasswords,
 257                                                      xIH1 );
 258             }
 259             else
 260                 m_xPasswordContainer->add( rURL,
 261                                            rUsername,
 262                                            rPasswords,
 263                                            xIH1 );
 264         }
 265         else
 266         {
 267             m_xPasswordContainer->addUrl( rURL, bPersist );
 268         }
 269     }
 270     catch ( task::NoMasterException const & )
 271     {
 272         // user did not enter master password
 273         return false;
 274     }
 275     return true;
 276 }
 277
 278
 279 PasswordContainerInteractionHandler::PasswordContainerInteractionHandler(
 280     const uno::Reference< uno::XComponentContext >& xContext )
 281 : m_aPwContainerHelper( xContext )
 282 {
 283 }
 284
 285
 286 // virtual
 287 PasswordContainerInteractionHandler::~PasswordContainerInteractionHandler()
 288 {
 289 }
 290
 291
 292 // XServiceInfo methods.
 293
 294
 295 // virtual
 296 OUString SAL_CALL
 297 PasswordContainerInteractionHandler::getImplementationName()
 298 {
 299     return getImplementationName_Static();
 300 }
 301
 302
 303 // virtual
 304 sal_Bool SAL_CALL
 305 PasswordContainerInteractionHandler::supportsService(
 306         const OUString& ServiceName )
 307 {
 308     return cppu::supportsService(this, ServiceName);
 309 }
 310
 311
 312 // virtual
 313 uno::Sequence< OUString > SAL_CALL
 314 PasswordContainerInteractionHandler::getSupportedServiceNames()
 315 {
 316     return getSupportedServiceNames_Static();
 317 }
 318
 319
 320 // static
 321 OUString
 322 PasswordContainerInteractionHandler::getImplementationName_Static()
 323 {
 324     return OUString( "com.sun.star.comp.uui.PasswordContainerInteractionHandler" );
 325 }
 326
 327
 328 // static
 329 uno::Sequence< OUString >
 330 PasswordContainerInteractionHandler::getSupportedServiceNames_Static()
 331 {
 332     uno::Sequence< OUString > aSNS { "com.sun.star.task.PasswordContainerInteractionHandler" };
 333     return aSNS;
 334 }
 335
 336
 337 // XInteractionHandler2 methods.
 338
 339
 340 // virtual
 341 void SAL_CALL
 342 PasswordContainerInteractionHandler::handle(
 343         const uno::Reference< task::XInteractionRequest >& rRequest )
 344 {
 345     handleInteractionRequest( rRequest );
 346 }
 347
 348 // virtual
 349 sal_Bool SAL_CALL
 350 PasswordContainerInteractionHandler::handleInteractionRequest(
 351         const uno::Reference< task::XInteractionRequest >& rRequest )
 352 {
 353     if ( !rRequest.is() )
 354         return false;
 355
 356     uno::Any aAnyRequest( rRequest->getRequest() );
 357
 358     ucb::AuthenticationRequest aAuthenticationRequest;
 359     if ( !( aAnyRequest >>= aAuthenticationRequest ) )
 360         return false;
 361
 362     OUString aURL;
 363     ucb::URLAuthenticationRequest aURLAuthenticationRequest;
 364     if ( aAnyRequest >>= aURLAuthenticationRequest )
 365         aURL = aURLAuthenticationRequest.URL;
 366
 367     uno::Sequence< uno::Reference< task::XInteractionContinuation > >
 368         rContinuations = rRequest->getContinuations();
 369
 370     uno::Reference< ucb::XInteractionSupplyAuthentication >
 371         xSupplyAuthentication;
 372
 373     for ( sal_Int32 i = 0; i < rContinuations.getLength(); ++i )
 374     {
 375         xSupplyAuthentication.set( rContinuations[i], uno::UNO_QUERY );
 376         if( xSupplyAuthentication.is() )
 377             break;
 378     }
 379
 380     if ( !xSupplyAuthentication.is() )
 381         return false;
 382
 383     // Try to obtain credentials from password container.
 384     if ( m_aPwContainerHelper.
 385              handleAuthenticationRequest( aAuthenticationRequest,
 386                                           xSupplyAuthentication,
 387                                           aURL,
 388                                           // @@@ FIXME: this not able to
 389                                           // handle master pw request!
 390                                           // master pw request is never
 391                                           // solvable without UI!
 392                                           this ) )
 393     {
 394         // successfully handled
 395         xSupplyAuthentication->select();
 396         return true;
 397     }
 398     return false;
 399 }
 400
 401
 402 // Service factory implementation.
 403
 404 /// @throws uno::Exception
 405 static uno::Reference< uno::XInterface >
 406 PasswordContainerInteractionHandler_CreateInstance(
 407         const uno::Reference< lang::XMultiServiceFactory> & rSMgr )
 408 {
 409     lang::XServiceInfo * pX = static_cast< lang::XServiceInfo * >(
 410         new PasswordContainerInteractionHandler( comphelper::getComponentContext(rSMgr) ) );
 411     return uno::Reference< uno::XInterface >::query( pX );
 412 }
 413
 414
 415 // static
 416 uno::Reference< lang::XSingleServiceFactory >
 417 PasswordContainerInteractionHandler::createServiceFactory(
 418     const uno::Reference< lang::XMultiServiceFactory >& rxServiceMgr )
 419 {
 420     return cppu::createOneInstanceFactory(
 421             rxServiceMgr,
 422             PasswordContainerInteractionHandler::getImplementationName_Static(),
 423             PasswordContainerInteractionHandler_CreateInstance,
 424             PasswordContainerInteractionHandler::getSupportedServiceNames_Static() );
 425 }
 426
 427 } // namespace uui
 428
 429 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */