svl/source/passwordcontainer/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 <sal/config.h>
  21 #include <sal/log.hxx>
  22
  23 #include <string_view>
  24
  25 #include "passwordcontainer.hxx"
  26
  27 #include <cppuhelper/factory.hxx>
  28 #include <cppuhelper/supportsservice.hxx>
  29 #include <comphelper/processfactory.hxx>
  30 #include <comphelper/propertyvalue.hxx>
  31 #include <comphelper/sequence.hxx>
  32 #include <o3tl/string_view.hxx>
  33 #include <com/sun/star/beans/PropertyValue.hpp>
  34 #include <com/sun/star/task/InteractionHandler.hpp>
  35 #include <com/sun/star/task/MasterPasswordRequest.hpp>
  36 #include <com/sun/star/task/NoMasterException.hpp>
  37 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  38
  39 #include <osl/diagnose.h>
  40 #include <rtl/character.hxx>
  41 #include <rtl/cipher.h>
  42 #include <rtl/digest.h>
  43 #include <rtl/byteseq.hxx>
  44 #include <rtl/ustrbuf.hxx>
  45
  46 using namespace osl;
  47 using namespace utl;
  48 using namespace com::sun::star;
  49 using namespace com::sun::star::uno;
  50 using namespace com::sun::star::registry;
  51 using namespace com::sun::star::lang;
  52 using namespace com::sun::star::task;
  53 using namespace com::sun::star::ucb;
  54
  55 static OUString createIndex(const std::vector< OUString >& lines)
  56 {
  57     OUStringBuffer aResult;
  58
  59     for( size_t i = 0; i < lines.size(); i++ )
  60     {
  61         if( i )
  62             aResult.append("__");
  63         OString line = OUStringToOString( lines[i], RTL_TEXTENCODING_UTF8 );
  64         const char* pLine = line.getStr();
  65
  66         while( *pLine )
  67         {
  68             if (rtl::isAsciiAlphanumeric(static_cast<unsigned char>(*pLine)))
  69             {
  70                 aResult.append(*pLine);
  71             }
  72             else
  73             {
  74                 aResult.append("_" + OUString::number(*pLine, 16) );
  75             }
  76
  77             pLine++;
  78         }
  79     }
  80
  81     return aResult.makeStringAndClear();
  82 }
  83
  84
  85 static std::vector< OUString > getInfoFromInd( std::u16string_view aInd )
  86 {
  87     std::vector< OUString > aResult;
  88     bool aStart = true;
  89
  90     OString line = OUStringToOString( aInd, RTL_TEXTENCODING_ASCII_US );
  91     const char* pLine = line.getStr();
  92     do
  93     {
  94         OUStringBuffer newItem;
  95         if( !aStart )
  96             pLine += 2;
  97         else
  98             aStart = false;
  99
 100         while( *pLine && ( pLine[0] != '_' || pLine[1] != '_' ))
 101             if( *pLine != '_' )
 102             {
 103                 newItem.append( *pLine );
 104                 pLine++;
 105             }
 106             else
 107             {
 108                 OUString aNum;
 109                 for( int i = 1; i < 3; i++ )
 110                 {
 111                     if( !pLine[i]
 112                       ||  ( ( pLine[i] < '0' || pLine[i] > '9' )
 113                          && ( pLine[i] < 'a' || pLine[i] > 'f' )
 114                          && ( pLine[i] < 'A' || pLine[i] > 'F' ) ) )
 115                     {
 116                         OSL_FAIL( "Wrong index syntax!" );
 117                         return aResult;
 118                     }
 119
 120                     aNum += OUStringChar( pLine[i] );
 121                 }
 122
 123                 newItem.append( sal_Unicode( aNum.toUInt32( 16 ) ) );
 124                 pLine += 3;
 125             }
 126
 127         aResult.push_back( newItem.makeStringAndClear() );
 128     } while( pLine[0] == '_' && pLine[1] == '_' );
 129
 130     if( *pLine )
 131         OSL_FAIL( "Wrong index syntax!" );
 132
 133     return aResult;
 134 }
 135
 136
 137 static bool shorterUrl( OUString& aURL )
 138 {
 139     sal_Int32 aInd = aURL.lastIndexOf( '/' );
 140     if( aInd > 0 && aURL.indexOf( "://" ) != aInd-2 )
 141     {
 142         aURL = aURL.copy( 0, aInd );
 143         return true;
 144     }
 145
 146     return false;
 147 }
 148
 149
 150 static OUString getAsciiLine( const ::rtl::ByteSequence& buf )
 151 {
 152     OUString aResult;
 153
 154     ::rtl::ByteSequence outbuf( buf.getLength()*2+1 );
 155
 156     for( int ind = 0; ind < buf.getLength(); ind++ )
 157     {
 158         outbuf[ind*2]   = ( static_cast<sal_uInt8>(buf[ind]) >> 4 ) + 'a';
 159         outbuf[ind*2+1] = ( static_cast<sal_uInt8>(buf[ind]) & 0x0f ) + 'a';
 160     }
 161     outbuf[buf.getLength()*2] = '\0';
 162
 163     aResult = OUString::createFromAscii( reinterpret_cast<char*>(outbuf.getArray()) );
 164
 165     return aResult;
 166 }
 167
 168
 169 static ::rtl::ByteSequence getBufFromAsciiLine( std::u16string_view line )
 170 {
 171     OSL_ENSURE( line.size() % 2 == 0, "Wrong syntax!" );
 172     OString tmpLine = OUStringToOString( line, RTL_TEXTENCODING_ASCII_US );
 173     ::rtl::ByteSequence aResult(line.size()/2);
 174
 175     for( int ind = 0; ind < tmpLine.getLength()/2; ind++ )
 176     {
 177         aResult[ind] = ( static_cast<sal_uInt8>( tmpLine[ind*2] - 'a' ) << 4 ) | static_cast<sal_uInt8>( tmpLine[ind*2+1] - 'a' );
 178     }
 179
 180     return aResult;
 181 }
 182
 183
 184 PasswordMap StorageItem::getInfo()
 185 {
 186     PasswordMap aResult;
 187
 188     const Sequence< OUString > aNodeNames     = ConfigItem::GetNodeNames( "Store" );
 189     sal_Int32 aNodeCount = aNodeNames.getLength();
 190     Sequence< OUString > aPropNames( aNodeCount * 2);
 191
 192     std::transform(aNodeNames.begin(), aNodeNames.end(), aPropNames.getArray(),
 193         [](const OUString& rName) -> OUString {
 194             return "Store/Passwordstorage['" + rName + "']/Password"; });
 195     std::transform(aNodeNames.begin(), aNodeNames.end(), aPropNames.getArray() + aNodeCount,
 196         [](const OUString& rName) -> OUString {
 197             return "Store/Passwordstorage['" + rName + "']/InitializationVector"; });
 198
 199     Sequence< Any > aPropertyValues = ConfigItem::GetProperties( aPropNames );
 200
 201     if( aPropertyValues.getLength() != aNodeCount * 2)
 202     {
 203         OSL_FAIL( "Problems during reading" );
 204         return aResult;
 205     }
 206
 207     for( sal_Int32 aNodeInd = 0; aNodeInd < aNodeCount; ++aNodeInd )
 208     {
 209         std::vector< OUString > aUrlUsr = getInfoFromInd( aNodeNames[aNodeInd] );
 210
 211         if( aUrlUsr.size() == 2 )
 212         {
 213             OUString aUrl  = aUrlUsr[0];
 214             OUString aName = aUrlUsr[1];
 215
 216             OUString aEPasswd;
 217             OUString aIV;
 218             aPropertyValues[aNodeInd] >>= aEPasswd;
 219             aPropertyValues[aNodeInd + aNodeCount] >>= aIV;
 220
 221             PasswordMap::iterator aIter = aResult.find( aUrl );
 222             if( aIter != aResult.end() )
 223                 aIter->second.emplace_back( aName, aEPasswd, aIV );
 224             else
 225             {
 226                 NamePasswordRecord aNewRecord( aName, aEPasswd, aIV );
 227                 std::vector< NamePasswordRecord > listToAdd( 1, aNewRecord );
 228
 229                 aResult.insert( PairUrlRecord( aUrl, listToAdd ) );
 230             }
 231         }
 232         else
 233             OSL_FAIL( "Wrong index syntax!" );
 234     }
 235
 236     return aResult;
 237 }
 238
 239
 240 void StorageItem::setUseStorage( bool bUse )
 241 {
 242     ConfigItem::SetModified();
 243     ConfigItem::PutProperties( { "UseStorage" }, { uno::Any(bUse) } );
 244 }
 245
 246
 247 bool StorageItem::useStorage()
 248 {
 249     Sequence<OUString> aNodeNames { "UseStorage" };
 250
 251     Sequence< Any > aPropertyValues = ConfigItem::GetProperties( aNodeNames );
 252
 253     if( aPropertyValues.getLength() != aNodeNames.getLength() )
 254     {
 255         OSL_FAIL( "Problems during reading" );
 256         return false;
 257     }
 258
 259     bool aResult = false;
 260     aPropertyValues[0] >>= aResult;
 261
 262     return aResult;
 263 }
 264
 265
 266 sal_Int32 StorageItem::getStorageVersion()
 267 {
 268     Sequence<OUString> aNodeNames { "StorageVersion" };
 269
 270     Sequence< Any > aPropertyValues = ConfigItem::GetProperties( aNodeNames );
 271
 272     if( aPropertyValues.getLength() != aNodeNames.getLength() )
 273     {
 274         OSL_FAIL( "Problems during reading" );
 275         return 0;
 276     }
 277
 278     sal_Int32 nResult = 0;
 279     aPropertyValues[0] >>= nResult;
 280
 281     return nResult;
 282 }
 283
 284 bool StorageItem::getEncodedMasterPassword( OUString& aResult, OUString& aResultIV )
 285 {
 286     if( hasEncoded )
 287     {
 288         aResult = mEncoded;
 289         aResultIV = mEncodedIV;
 290         return true;
 291     }
 292
 293     Sequence< OUString > aNodeNames{ "HasMaster", "Master", "MasterInitializationVector" };
 294
 295     Sequence< Any > aPropertyValues = ConfigItem::GetProperties( aNodeNames );
 296
 297     if( aPropertyValues.getLength() != aNodeNames.getLength() )
 298     {
 299         OSL_FAIL( "Problems during reading" );
 300         return false;
 301     }
 302
 303     aPropertyValues[0] >>= hasEncoded;
 304     aPropertyValues[1] >>= mEncoded;
 305     aPropertyValues[2] >>= mEncodedIV;
 306
 307     aResult = mEncoded;
 308     aResultIV = mEncodedIV;
 309
 310     return hasEncoded;
 311 }
 312
 313
 314 void StorageItem::setEncodedMasterPassword( const OUString& aEncoded, const OUString& aEncodedIV, bool bAcceptEmpty )
 315 {
 316     bool bHasMaster = ( !aEncoded.isEmpty() || bAcceptEmpty );
 317
 318     ConfigItem::SetModified();
 319     ConfigItem::PutProperties( { "HasMaster", "Master", "MasterInitializationVector", "StorageVersion" },
 320                                { uno::Any(bHasMaster), uno::Any(aEncoded),
 321                                  uno::Any(aEncodedIV), uno::Any(nCurrentStorageVersion) } );
 322
 323     hasEncoded = bHasMaster;
 324     mEncoded = aEncoded;
 325     mEncodedIV = aEncodedIV;
 326 }
 327
 328
 329 void StorageItem::remove( const OUString& aURL, const OUString& aName )
 330 {
 331     Sequence< OUString > sendSeq { createIndex( { aURL, aName } ) };
 332
 333     ConfigItem::ClearNodeElements( "Store", sendSeq );
 334 }
 335
 336
 337 void StorageItem::clear()
 338 {
 339     ConfigItem::ClearNodeSet( "Store" );
 340 }
 341
 342
 343 void StorageItem::update( const OUString& aURL, const NamePasswordRecord& aRecord )
 344 {
 345     if ( !aRecord.HasPasswords( PERSISTENT_RECORD ) )
 346     {
 347         OSL_FAIL( "Unexpected storing of a record!" );
 348         return;
 349     }
 350
 351     Sequence< beans::PropertyValue > sendSeq{ comphelper::makePropertyValue(
 352         "Store/Passwordstorage['" + createIndex( { aURL, aRecord.GetUserName() } ) + "']/InitializationVector",
 353         aRecord.GetPersistentIV()), comphelper::makePropertyValue(
 354         "Store/Passwordstorage['" + createIndex( { aURL, aRecord.GetUserName() } ) + "']/Password",
 355         aRecord.GetPersistentPasswords()) };
 356
 357     ConfigItem::SetModified();
 358     ConfigItem::SetSetProperties( "Store", sendSeq );
 359 }
 360
 361
 362 void StorageItem::Notify( const Sequence< OUString >& )
 363 {
 364     // this feature still should not be used
 365     if( mainCont )
 366         mainCont->Notify();
 367 }
 368
 369
 370 void StorageItem::ImplCommit()
 371 {
 372     // Do nothing, we stored everything we want already
 373 }
 374
 375
 376 PasswordContainer::PasswordContainer( const Reference<XComponentContext>& rxContext )
 377 {
 378     // m_pStorageFile->Notify() can be called
 379     std::unique_lock aGuard( mMutex );
 380
 381     mComponent.set( rxContext->getServiceManager(), UNO_QUERY );
 382     mComponent->addEventListener( this );
 383
 384     m_xStorageFile.emplace( this, "Office.Common/Passwords" );
 385     if( m_xStorageFile->useStorage() )
 386         m_aContainer = m_xStorageFile->getInfo();
 387 }
 388
 389
 390 PasswordContainer::~PasswordContainer()
 391 {
 392     std::unique_lock aGuard( mMutex );
 393
 394     m_xStorageFile.reset();
 395
 396     if( mComponent.is() )
 397     {
 398         mComponent->removeEventListener(this);
 399         mComponent.clear();
 400     }
 401 }
 402
 403 void SAL_CALL PasswordContainer::disposing( const EventObject& )
 404 {
 405     std::unique_lock aGuard( mMutex );
 406
 407     m_xStorageFile.reset();
 408
 409     if( mComponent.is() )
 410     {
 411         //mComponent->removeEventListener(this);
 412         mComponent.clear();
 413     }
 414 }
 415
 416 std::vector< OUString > PasswordContainer::DecodePasswords( std::u16string_view aLine, std::u16string_view aIV, std::u16string_view aMasterPasswd, css::task::PasswordRequestMode mode )
 417 {
 418     if( !aMasterPasswd.empty() )
 419     {
 420         rtlCipher aDecoder = rtl_cipher_create (rtl_Cipher_AlgorithmBF, rtl_Cipher_ModeStream );
 421         OSL_ENSURE( aDecoder, "Can't create decoder" );
 422
 423         if( aDecoder )
 424         {
 425             OSL_ENSURE( aMasterPasswd.size() == RTL_DIGEST_LENGTH_MD5 * 2, "Wrong master password format!" );
 426
 427             unsigned char code[RTL_DIGEST_LENGTH_MD5];
 428             for( int ind = 0; ind < RTL_DIGEST_LENGTH_MD5; ind++ )
 429                 code[ ind ] = static_cast<char>(o3tl::toUInt32(aMasterPasswd.substr( ind*2, 2 ), 16));
 430
 431             unsigned char iv[RTL_DIGEST_LENGTH_MD5] = {0};
 432             if (!aIV.empty())
 433             {
 434                 for( int ind = 0; ind < RTL_DIGEST_LENGTH_MD5; ind++ )
 435                 {
 436                     auto tmp = aIV.substr( ind*2, 2 );
 437                     iv[ ind ] = static_cast<char>(rtl_ustr_toInt64_WithLength(tmp.data(), 16, tmp.size()));
 438                 }
 439             }
 440
 441             rtlCipherError result = rtl_cipher_init (
 442                     aDecoder, rtl_Cipher_DirectionDecode,
 443                     code, RTL_DIGEST_LENGTH_MD5, iv, RTL_DIGEST_LENGTH_MD5 );
 444
 445             if( result == rtl_Cipher_E_None )
 446             {
 447                 ::rtl::ByteSequence aSeq = getBufFromAsciiLine( aLine );
 448
 449                 ::rtl::ByteSequence resSeq( aSeq.getLength() );
 450
 451                 rtl_cipher_decode ( aDecoder, aSeq.getArray(), aSeq.getLength(),
 452                                                         reinterpret_cast<sal_uInt8*>(resSeq.getArray()), resSeq.getLength() );
 453
 454                 OUString aPasswd( reinterpret_cast<char*>(resSeq.getArray()), resSeq.getLength(), RTL_TEXTENCODING_UTF8 );
 455
 456                 rtl_cipher_destroy (aDecoder);
 457
 458                 return getInfoFromInd( aPasswd );
 459             }
 460
 461             rtl_cipher_destroy (aDecoder);
 462         }
 463     }
 464     else
 465     {
 466         OSL_FAIL( "No master password provided!" );
 467         // throw special exception
 468     }
 469
 470     // problems with decoding
 471     OSL_FAIL( "Problem with decoding" );
 472     throw css::task::NoMasterException(
 473         "Can't decode!", css::uno::Reference<css::uno::XInterface>(), mode);
 474 }
 475
 476 OUString PasswordContainer::EncodePasswords(const std::vector< OUString >& lines, std::u16string_view aIV, std::u16string_view aMasterPasswd)
 477 {
 478     if( !aMasterPasswd.empty() )
 479     {
 480         OString aSeq = OUStringToOString( createIndex( lines ), RTL_TEXTENCODING_UTF8 );
 481
 482         rtlCipher aEncoder = rtl_cipher_create (rtl_Cipher_AlgorithmBF, rtl_Cipher_ModeStream );
 483         OSL_ENSURE( aEncoder, "Can't create encoder" );
 484
 485         if( aEncoder )
 486         {
 487             OSL_ENSURE( aMasterPasswd.size() == RTL_DIGEST_LENGTH_MD5 * 2, "Wrong master password format!" );
 488
 489             unsigned char code[RTL_DIGEST_LENGTH_MD5];
 490             for( int ind = 0; ind < RTL_DIGEST_LENGTH_MD5; ind++ )
 491                 code[ ind ] = static_cast<char>(o3tl::toUInt32(aMasterPasswd.substr( ind*2, 2 ), 16));
 492
 493             unsigned char iv[RTL_DIGEST_LENGTH_MD5] = {0};
 494             if (!aIV.empty())
 495             {
 496                 for( int ind = 0; ind < RTL_DIGEST_LENGTH_MD5; ind++ )
 497                 {
 498                     auto tmp = aIV.substr( ind*2, 2 );
 499                     iv[ ind ] = static_cast<char>(rtl_ustr_toInt64_WithLength(tmp.data(), 16, tmp.size()));
 500                 }
 501             }
 502
 503             rtlCipherError result = rtl_cipher_init (
 504                     aEncoder, rtl_Cipher_DirectionEncode,
 505                     code, RTL_DIGEST_LENGTH_MD5, iv, RTL_DIGEST_LENGTH_MD5 );
 506
 507             if( result == rtl_Cipher_E_None )
 508             {
 509                 ::rtl::ByteSequence resSeq(aSeq.getLength()+1);
 510
 511                 result = rtl_cipher_encode ( aEncoder, aSeq.getStr(), aSeq.getLength()+1,
 512                                                         reinterpret_cast<sal_uInt8*>(resSeq.getArray()), resSeq.getLength() );
 513
 514 /*
 515                 //test
 516                 rtlCipherError result = rtl_cipher_init (
 517                     aEncoder, rtl_Cipher_DirectionDecode,
 518                     code, RTL_DIGEST_LENGTH_MD5, NULL, 0 );
 519
 520
 521                 if( result == rtl_Cipher_E_None )
 522                 {
 523                     OUString testOU = getAsciiLine( resSeq );
 524                     ::rtl::ByteSequence aSeq1 = getBufFromAsciiLine( testOU );
 525
 526                     ::rtl::ByteSequence resSeq1( aSeq1.getLength() );
 527
 528                     if( resSeq.getLength() == aSeq1.getLength() )
 529                     {
 530                         for( int ind = 0; ind < aSeq1.getLength(); ind++ )
 531                             if( resSeq[ind] != aSeq1[ind] )
 532                                 testOU = "";
 533                     }
 534
 535                     result = rtl_cipher_decode ( aEncoder, (sal_uInt8*)aSeq1.getArray(), aSeq1.getLength(),
 536                                                         (sal_uInt8*)resSeq1.getArray(), resSeq1.getLength() );
 537
 538                     OUString aPasswd( ( char* )resSeq1.getArray(), resSeq1.getLength(), RTL_TEXTENCODING_UTF8 );
 539                 }
 540 */
 541
 542                 rtl_cipher_destroy (aEncoder);
 543
 544                 if( result == rtl_Cipher_E_None )
 545                     return getAsciiLine( resSeq );
 546
 547             }
 548
 549             rtl_cipher_destroy (aEncoder);
 550         }
 551     }
 552     else
 553     {
 554         OSL_FAIL( "No master password provided!" );
 555         // throw special exception
 556     }
 557
 558     // problems with encoding
 559     OSL_FAIL( "Problem with encoding" );
 560     throw RuntimeException("Can't encode!" );
 561 }
 562
 563 void PasswordContainer::UpdateVector( const OUString& aURL, std::vector< NamePasswordRecord >& toUpdate, NamePasswordRecord const & aRecord, bool writeFile )
 564 {
 565     for (auto & aNPIter : toUpdate)
 566         if( aNPIter.GetUserName() == aRecord.GetUserName() )
 567         {
 568             if( aRecord.HasPasswords( MEMORY_RECORD ) )
 569                 aNPIter.SetMemoryPasswords( aRecord.GetMemoryPasswords() );
 570
 571             if( aRecord.HasPasswords( PERSISTENT_RECORD ) )
 572             {
 573                 aNPIter.SetPersistentPasswords( aRecord.GetPersistentPasswords(), aRecord.GetPersistentIV() );
 574
 575                 if( writeFile )
 576                 {
 577                     // the password must be already encoded
 578                     m_xStorageFile->update( aURL, aRecord ); // change existing ( aURL, aName ) record in the configfile
 579                 }
 580             }
 581
 582             return;
 583         }
 584
 585
 586     if( aRecord.HasPasswords( PERSISTENT_RECORD ) && writeFile )
 587     {
 588         // the password must be already encoded
 589         m_xStorageFile->update( aURL, aRecord ); // add new aName to the existing url
 590     }
 591
 592     toUpdate.insert( toUpdate.begin(), aRecord );
 593 }
 594
 595
 596 UserRecord PasswordContainer::CopyToUserRecord( const NamePasswordRecord& aRecord, bool& io_bTryToDecode, const Reference< XInteractionHandler >& aHandler )
 597 {
 598     ::std::vector< OUString > aPasswords;
 599     if( aRecord.HasPasswords( MEMORY_RECORD ) )
 600         aPasswords = aRecord.GetMemoryPasswords();
 601
 602     if( io_bTryToDecode && aRecord.HasPasswords( PERSISTENT_RECORD ) )
 603     {
 604         try
 605         {
 606             ::std::vector< OUString > aDecodedPasswords = DecodePasswords( aRecord.GetPersistentPasswords(), aRecord.GetPersistentIV(),
 607                                                                            GetMasterPassword( aHandler ), css::task::PasswordRequestMode_PASSWORD_ENTER );
 608             aPasswords.insert( aPasswords.end(), aDecodedPasswords.begin(), aDecodedPasswords.end() );
 609         }
 610         catch( NoMasterException& )
 611         {
 612             // if master password could not be detected the entry will be just ignored
 613             io_bTryToDecode = false;
 614         }
 615     }
 616
 617     return UserRecord( aRecord.GetUserName(), comphelper::containerToSequence( aPasswords ) );
 618 }
 619
 620
 621 Sequence< UserRecord > PasswordContainer::CopyToUserRecordSequence( const std::vector< NamePasswordRecord >& original, const Reference< XInteractionHandler >& aHandler )
 622 {
 623     Sequence< UserRecord >     aResult( original.size() );
 624     auto aResultRange = asNonConstRange(aResult);
 625     sal_uInt32 nInd = 0;
 626     bool bTryToDecode = true;
 627
 628     for (auto const& aNPIter : original)
 629     {
 630         aResultRange[nInd] = CopyToUserRecord( aNPIter, bTryToDecode, aHandler );
 631         ++nInd;
 632     }
 633
 634     return aResult;
 635 }
 636
 637
 638 void SAL_CALL PasswordContainer::add( const OUString& Url, const OUString& UserName, const Sequence< OUString >& Passwords, const Reference< XInteractionHandler >& aHandler )
 639 {
 640     std::unique_lock aGuard( mMutex );
 641
 642     PrivateAdd( Url, UserName, Passwords, MEMORY_RECORD, aHandler );
 643 }
 644
 645
 646 void SAL_CALL PasswordContainer::addPersistent( const OUString& Url, const OUString& UserName, const Sequence< OUString >& Passwords, const Reference< XInteractionHandler >& aHandler  )
 647 {
 648     std::unique_lock aGuard( mMutex );
 649
 650     PrivateAdd( Url, UserName, Passwords, PERSISTENT_RECORD, aHandler );
 651 }
 652
 653 OUString PasswordContainer::createIV()
 654 {
 655     unsigned char iv[RTL_DIGEST_LENGTH_MD5];
 656     if (rtl_random_getBytes(nullptr, iv, RTL_DIGEST_LENGTH_MD5) != rtl_Random_E_None)
 657     {
 658         throw uno::RuntimeException("rtl_random_getBytes failed");
 659     }
 660     OUStringBuffer aBuffer;
 661     for (sal_uInt8 i : iv)
 662     {
 663         aBuffer.append(OUString::number(i >> 4, 16) + OUString::number(i & 15, 16));
 664     }
 665     return aBuffer.makeStringAndClear();
 666 }
 667
 668 void PasswordContainer::PrivateAdd( const OUString& Url, const OUString& UserName, const Sequence< OUString >& Passwords, char Mode, const Reference< XInteractionHandler >& aHandler )
 669 {
 670     NamePasswordRecord aRecord( UserName );
 671     ::std::vector< OUString > aStorePass = comphelper::sequenceToContainer< std::vector<OUString> >( Passwords );
 672
 673     if( Mode == PERSISTENT_RECORD )
 674     {
 675         OUString sIV = createIV();
 676         OUString sEncodedPasswords = EncodePasswords(aStorePass, sIV, GetMasterPassword(aHandler));
 677         aRecord.SetPersistentPasswords(sEncodedPasswords, sIV);
 678     }
 679     else if( Mode == MEMORY_RECORD )
 680         aRecord.SetMemoryPasswords( std::move(aStorePass) );
 681     else
 682     {
 683         OSL_FAIL( "Unexpected persistence status!" );
 684         return;
 685     }
 686
 687     if( !m_aContainer.empty() )
 688     {
 689         PasswordMap::iterator aIter = m_aContainer.find( Url );
 690
 691         if( aIter != m_aContainer.end() )
 692         {
 693             UpdateVector( aIter->first, aIter->second, aRecord, true );
 694             return;
 695         }
 696     }
 697
 698     std::vector< NamePasswordRecord > listToAdd( 1, aRecord );
 699     m_aContainer.insert( PairUrlRecord( Url, listToAdd ) );
 700
 701     if( Mode == PERSISTENT_RECORD && m_xStorageFile && m_xStorageFile->useStorage() )
 702         m_xStorageFile->update( Url, aRecord );
 703
 704 }
 705
 706
 707 UrlRecord SAL_CALL PasswordContainer::find( const OUString& aURL, const Reference< XInteractionHandler >& aHandler  )
 708 {
 709     return find( aURL, u"", false, aHandler );
 710 }
 711
 712
 713 UrlRecord SAL_CALL PasswordContainer::findForName( const OUString& aURL, const OUString& aName, const Reference< XInteractionHandler >& aHandler  )
 714 {
 715     return find( aURL, aName, true, aHandler );
 716 }
 717
 718
 719 Sequence< UserRecord > PasswordContainer::FindUsr( const std::vector< NamePasswordRecord >& userlist, std::u16string_view aName, const Reference< XInteractionHandler >& aHandler )
 720 {
 721     for (auto const& aNPIter : userlist)
 722     {
 723         if( aNPIter.GetUserName() == aName )
 724         {
 725             bool bTryToDecode = true;
 726             Sequence< UserRecord > aResult { CopyToUserRecord( aNPIter, bTryToDecode, aHandler ) };
 727
 728             return aResult;
 729         }
 730     }
 731
 732     return Sequence< UserRecord >();
 733 }
 734
 735
 736 bool PasswordContainer::createUrlRecord(
 737     const PasswordMap::iterator & rIter,
 738     bool bName,
 739     std::u16string_view aName,
 740     const Reference< XInteractionHandler >& aHandler,
 741     UrlRecord & rRec )
 742 {
 743     if ( bName )
 744     {
 745         Sequence< UserRecord > aUsrRec
 746             = FindUsr( rIter->second, aName, aHandler );
 747         if( aUsrRec.hasElements() )
 748         {
 749             rRec = UrlRecord( rIter->first, aUsrRec );
 750             return true;
 751         }
 752     }
 753     else
 754     {
 755         rRec = UrlRecord(
 756             rIter->first,
 757             CopyToUserRecordSequence( rIter->second, aHandler ) );
 758         return true;
 759     }
 760     return false;
 761 }
 762
 763
 764 UrlRecord PasswordContainer::find(
 765     const OUString& aURL,
 766     std::u16string_view aName,
 767     bool bName, // only needed to support empty user names
 768     const Reference< XInteractionHandler >& aHandler  )
 769 {
 770     std::unique_lock aGuard( mMutex );
 771
 772     if( !m_aContainer.empty() && !aURL.isEmpty() )
 773     {
 774         OUString aUrl( aURL );
 775
 776         // each iteration remove last '/...' section from the aUrl
 777         // while it's possible, up to the most left '://'
 778         do
 779         {
 780             // first look for <url>/somename and then look for <url>/somename/...
 781             PasswordMap::iterator aIter = m_aContainer.find( aUrl );
 782             if( aIter != m_aContainer.end() )
 783             {
 784                 UrlRecord aRec;
 785                 if ( createUrlRecord( aIter, bName, aName, aHandler, aRec ) )
 786                   return aRec;
 787             }
 788             else
 789             {
 790                 OUString tmpUrl( aUrl );
 791                 if ( !tmpUrl.endsWith("/") )
 792                     tmpUrl += "/";
 793
 794                 aIter = m_aContainer.lower_bound( tmpUrl );
 795                 if( aIter != m_aContainer.end() && aIter->first.match( tmpUrl ) )
 796                 {
 797                     UrlRecord aRec;
 798                     if ( createUrlRecord( aIter, bName, aName, aHandler, aRec ) )
 799                       return aRec;
 800                 }
 801             }
 802         }
 803         while( shorterUrl( aUrl ) && !aUrl.isEmpty() );
 804     }
 805
 806     return UrlRecord();
 807 }
 808
 809 OUString PasswordContainer::GetDefaultMasterPassword()
 810 {
 811     OUStringBuffer aResult;
 812     for ( sal_Int32 nInd = 0; nInd < RTL_DIGEST_LENGTH_MD5; nInd++ )
 813         aResult.append("aa");
 814
 815     return aResult.makeStringAndClear();
 816 }
 817
 818 OUString PasswordContainer::RequestPasswordFromUser( PasswordRequestMode aRMode, const uno::Reference< task::XInteractionHandler >& xHandler )
 819 {
 820     // empty string means that the call was cancelled or just failed
 821     OUString aResult;
 822
 823     if ( xHandler.is() )
 824     {
 825         ::rtl::Reference< MasterPasswordRequest_Impl > xRequest = new MasterPasswordRequest_Impl( aRMode );
 826
 827         xHandler->handle( xRequest );
 828
 829         ::rtl::Reference< ucbhelper::InteractionContinuation > xSelection = xRequest->getSelection();
 830
 831         if ( xSelection.is() )
 832         {
 833             Reference< XInteractionAbort > xAbort( xSelection.get(), UNO_QUERY );
 834             if ( !xAbort.is() )
 835             {
 836                 const ::rtl::Reference< ucbhelper::InteractionSupplyAuthentication > & xSupp
 837                             = xRequest->getAuthenticationSupplier();
 838
 839                 aResult = xSupp->getPassword();
 840             }
 841         }
 842     }
 843
 844     return aResult;
 845 }
 846
 847 // Mangle the key to match an old bug
 848 static OUString ReencodeAsOldHash(std::u16string_view rPass)
 849 {
 850     OUStringBuffer aBuffer;
 851     for (int ind = 0; ind < RTL_DIGEST_LENGTH_MD5; ++ind)
 852     {
 853         auto tmp = rPass.substr(ind * 2, 2);
 854         unsigned char i = static_cast<char>(rtl_ustr_toInt64_WithLength(tmp.data(), 16, tmp.size()));
 855         aBuffer.append(OUStringChar(static_cast< sal_Unicode >('a' + (i >> 4)))
 856                 + OUStringChar(static_cast< sal_Unicode >('a' + (i & 15))));
 857     }
 858     return aBuffer.makeStringAndClear();
 859 }
 860
 861 OUString const & PasswordContainer::GetMasterPassword( const Reference< XInteractionHandler >& aHandler )
 862 {
 863     PasswordRequestMode aRMode = PasswordRequestMode_PASSWORD_ENTER;
 864     if( !m_xStorageFile || !m_xStorageFile->useStorage() )
 865         throw NoMasterException("Password storing is not active!", Reference< XInterface >(), aRMode );
 866
 867     if( m_aMasterPassword.isEmpty() && aHandler.is() )
 868     {
 869         OUString aEncodedMP, aEncodedMPIV;
 870         bool bDefaultPassword = false;
 871
 872         if( !m_xStorageFile->getEncodedMasterPassword( aEncodedMP, aEncodedMPIV ) )
 873             aRMode = PasswordRequestMode_PASSWORD_CREATE;
 874         else if ( aEncodedMP.isEmpty() )
 875         {
 876             m_aMasterPassword = GetDefaultMasterPassword();
 877             bDefaultPassword = true;
 878         }
 879
 880         if ( !bDefaultPassword )
 881         {
 882             bool bAskAgain = false;
 883             do {
 884                 bAskAgain = false;
 885
 886                 OUString aPass = RequestPasswordFromUser( aRMode, aHandler );
 887                 if ( !aPass.isEmpty() )
 888                 {
 889                     if( aRMode == PasswordRequestMode_PASSWORD_CREATE )
 890                     {
 891                         m_aMasterPassword = aPass;
 892                         std::vector< OUString > aMaster( 1, m_aMasterPassword );
 893
 894                         OUString sIV = createIV();
 895                         m_xStorageFile->setEncodedMasterPassword(EncodePasswords(aMaster, sIV, m_aMasterPassword), sIV);
 896                     }
 897                     else
 898                     {
 899                         if (m_xStorageFile->getStorageVersion() == 0)
 900                             aPass = ReencodeAsOldHash(aPass);
 901
 902                         std::vector< OUString > aRM( DecodePasswords( aEncodedMP, aEncodedMPIV, aPass, aRMode ) );
 903                         if( aRM.empty() || aPass != aRM[0] )
 904                         {
 905                             bAskAgain = true;
 906                             aRMode = PasswordRequestMode_PASSWORD_REENTER;
 907                         }
 908                         else
 909                             m_aMasterPassword = aPass;
 910                     }
 911                 }
 912
 913             } while( bAskAgain );
 914         }
 915     }
 916
 917     if ( m_aMasterPassword.isEmpty() )
 918         throw NoMasterException("No master password!", Reference< XInterface >(), aRMode );
 919
 920     return m_aMasterPassword;
 921 }
 922
 923
 924 void SAL_CALL PasswordContainer::remove( const OUString& aURL, const OUString& aName )
 925 {
 926     std::unique_lock aGuard( mMutex );
 927
 928     OUString aUrl( aURL );
 929     if( m_aContainer.empty() )
 930         return;
 931
 932     PasswordMap::iterator aIter = m_aContainer.find( aUrl );
 933
 934     if( aIter == m_aContainer.end() )
 935     {
 936         if( aUrl.endsWith("/") )
 937             aUrl = aUrl.copy( 0, aUrl.getLength() - 1 );
 938         else
 939             aUrl += "/";
 940
 941         aIter = m_aContainer.find( aUrl );
 942     }
 943
 944     if( aIter == m_aContainer.end() )
 945         return;
 946
 947     auto aNPIter = std::find_if(aIter->second.begin(), aIter->second.end(),
 948         [&aName](const NamePasswordRecord& rNPRecord) { return rNPRecord.GetUserName() == aName; });
 949
 950     if (aNPIter != aIter->second.end())
 951     {
 952         if( aNPIter->HasPasswords( PERSISTENT_RECORD ) && m_xStorageFile )
 953             m_xStorageFile->remove( aURL, aName ); // remove record ( aURL, aName )
 954
 955         // the iterator will not be used any more so it can be removed directly
 956         aIter->second.erase( aNPIter );
 957
 958         if( aIter->second.empty() )
 959             m_aContainer.erase( aIter );
 960     }
 961 }
 962
 963
 964 void SAL_CALL PasswordContainer::removePersistent( const OUString& aURL, const OUString& aName )
 965 {
 966     std::unique_lock aGuard( mMutex );
 967
 968     OUString aUrl( aURL );
 969     if( m_aContainer.empty() )
 970         return;
 971
 972     PasswordMap::iterator aIter = m_aContainer.find( aUrl );
 973
 974     if( aIter == m_aContainer.end() )
 975     {
 976         if( aUrl.endsWith("/") )
 977             aUrl = aUrl.copy( 0, aUrl.getLength() - 1 );
 978         else
 979             aUrl += "/";
 980
 981         aIter = m_aContainer.find( aUrl );
 982     }
 983
 984     if( aIter == m_aContainer.end() )
 985         return;
 986
 987     auto aNPIter = std::find_if(aIter->second.begin(), aIter->second.end(),
 988         [&aName](const NamePasswordRecord& rNPRecord) { return rNPRecord.GetUserName() == aName; });
 989
 990     if (aNPIter == aIter->second.end())
 991         return;
 992
 993     if( aNPIter->HasPasswords( PERSISTENT_RECORD ) )
 994     {
 995         // TODO/LATER: should the password be converted to MemoryPassword?
 996         aNPIter->RemovePasswords( PERSISTENT_RECORD );
 997
 998         if ( m_xStorageFile )
 999             m_xStorageFile->remove( aURL, aName ); // remove record ( aURL, aName )
1000     }
1001
1002     if( !aNPIter->HasPasswords( MEMORY_RECORD ) )
1003         aIter->second.erase( aNPIter );
1004
1005     if( aIter->second.empty() )
1006         m_aContainer.erase( aIter );
1007 }
1008
1009 void SAL_CALL PasswordContainer::removeAllPersistent()
1010 {
1011     std::unique_lock aGuard(mMutex);
1012     removeAllPersistent(aGuard);
1013 }
1014
1015 void PasswordContainer::removeAllPersistent(std::unique_lock<std::mutex>& /*rGuard*/)
1016 {
1017     if( m_xStorageFile )
1018         m_xStorageFile->clear();
1019
1020     for( PasswordMap::iterator aIter = m_aContainer.begin(); aIter != m_aContainer.end(); )
1021     {
1022         for( std::vector< NamePasswordRecord >::iterator aNPIter = aIter->second.begin(); aNPIter != aIter->second.end(); )
1023         {
1024             if( aNPIter->HasPasswords( PERSISTENT_RECORD ) )
1025             {
1026                 // TODO/LATER: should the password be converted to MemoryPassword?
1027                 aNPIter->RemovePasswords( PERSISTENT_RECORD );
1028
1029                 if ( m_xStorageFile )
1030                     m_xStorageFile->remove( aIter->first, aNPIter->GetUserName() ); // remove record ( aURL, aName )
1031             }
1032
1033             if( !aNPIter->HasPasswords( MEMORY_RECORD ) )
1034             {
1035                 aNPIter = aIter->second.erase(aNPIter);
1036             }
1037             else
1038                 ++aNPIter;
1039         }
1040
1041         if( aIter->second.empty() )
1042         {
1043             aIter = m_aContainer.erase(aIter);
1044         }
1045         else
1046             ++aIter;
1047     }
1048 }
1049
1050 Sequence< UrlRecord > SAL_CALL PasswordContainer::getAllPersistent( const Reference< XInteractionHandler >& xHandler )
1051 {
1052     std::unique_lock aGuard( mMutex );
1053     return getAllPersistent(aGuard, xHandler);
1054 }
1055
1056 Sequence< UrlRecord > PasswordContainer::getAllPersistent( std::unique_lock<std::mutex>& /*rGuard*/, const Reference< XInteractionHandler >& xHandler )
1057 {
1058     Sequence< UrlRecord > aResult;
1059
1060     for( const auto& rEntry : m_aContainer )
1061     {
1062         Sequence< UserRecord > aUsers;
1063         for (auto const& aNP : rEntry.second)
1064             if( aNP.HasPasswords( PERSISTENT_RECORD ) )
1065             {
1066                 sal_Int32 oldLen = aUsers.getLength();
1067                 aUsers.realloc( oldLen + 1 );
1068                 aUsers.getArray()[ oldLen ] = UserRecord( aNP.GetUserName(), comphelper::containerToSequence( DecodePasswords( aNP.GetPersistentPasswords(), aNP.GetPersistentIV(),
1069                                                                                                                                GetMasterPassword( xHandler ), css::task::PasswordRequestMode_PASSWORD_ENTER ) ) );
1070             }
1071
1072         if( aUsers.hasElements() )
1073         {
1074             sal_Int32 oldLen = aResult.getLength();
1075             aResult.realloc( oldLen + 1 );
1076             aResult.getArray()[ oldLen ] = UrlRecord( rEntry.first, aUsers );
1077         }
1078     }
1079
1080     return aResult;
1081 }
1082
1083 sal_Bool SAL_CALL PasswordContainer::authorizateWithMasterPassword( const uno::Reference< task::XInteractionHandler >& xHandler )
1084 {
1085     std::unique_lock aGuard( mMutex );
1086     return authorizateWithMasterPassword(aGuard, xHandler);
1087 }
1088
1089 bool PasswordContainer::authorizateWithMasterPassword( std::unique_lock<std::mutex>& /*rGuard*/, const uno::Reference< task::XInteractionHandler >& xHandler )
1090 {
1091     bool bResult = false;
1092     OUString aEncodedMP, aEncodedMPIV;
1093     uno::Reference< task::XInteractionHandler > xTmpHandler = xHandler;
1094
1095     // the method should fail if there is no master password
1096     if( m_xStorageFile && m_xStorageFile->useStorage() && m_xStorageFile->getEncodedMasterPassword( aEncodedMP, aEncodedMPIV ) )
1097     {
1098         if ( aEncodedMP.isEmpty() )
1099         {
1100             // this is a default master password
1101             // no UI is necessary
1102             bResult = true;
1103         }
1104         else
1105         {
1106             if ( !xTmpHandler.is() )
1107             {
1108                 uno::Reference< lang::XMultiServiceFactory > xFactory( mComponent, uno::UNO_QUERY_THROW );
1109                 uno::Reference< uno::XComponentContext > xContext( comphelper::getComponentContext(xFactory) );
1110                 xTmpHandler.set( InteractionHandler::createWithParent(xContext, nullptr), uno::UNO_QUERY_THROW );
1111             }
1112
1113             if ( !m_aMasterPassword.isEmpty() )
1114             {
1115                 // there is a password, it should be just rechecked
1116                 PasswordRequestMode aRMode = PasswordRequestMode_PASSWORD_ENTER;
1117                 OUString aPass;
1118
1119                 do {
1120                     aPass = RequestPasswordFromUser( aRMode, xTmpHandler );
1121
1122                     if (!aPass.isEmpty() && m_xStorageFile->getStorageVersion() == 0)
1123                     {
1124                         aPass = ReencodeAsOldHash(aPass);
1125                     }
1126
1127                     bResult = ( !aPass.isEmpty() && aPass == m_aMasterPassword );
1128                     aRMode = PasswordRequestMode_PASSWORD_REENTER; // further questions with error notification
1129                 } while( !bResult && !aPass.isEmpty() );
1130             }
1131             else
1132             {
1133                 try
1134                 {
1135                     // ask for the password, if user provide no correct password an exception will be thrown
1136                     bResult = !GetMasterPassword( xTmpHandler ).isEmpty();
1137                 }
1138                 catch( uno::Exception& )
1139                 {}
1140             }
1141         }
1142     }
1143
1144     return bResult;
1145 }
1146
1147 sal_Bool SAL_CALL PasswordContainer::changeMasterPassword( const uno::Reference< task::XInteractionHandler >& xHandler )
1148 {
1149     bool bResult = false;
1150     uno::Reference< task::XInteractionHandler > xTmpHandler = xHandler;
1151     std::unique_lock aGuard( mMutex );
1152
1153     if ( m_xStorageFile && m_xStorageFile->useStorage() )
1154     {
1155         if ( !xTmpHandler.is() )
1156         {
1157             uno::Reference< lang::XMultiServiceFactory > xFactory( mComponent, uno::UNO_QUERY_THROW );
1158             uno::Reference< uno::XComponentContext > xContext( comphelper::getComponentContext(xFactory) );
1159             xTmpHandler.set( InteractionHandler::createWithParent(xContext, nullptr), uno::UNO_QUERY_THROW );
1160         }
1161
1162         bool bCanChangePassword = true;
1163         // if there is already a stored master password it should be entered by the user before the change happen
1164         OUString aEncodedMP, aEncodedMPIV;
1165         if( !m_aMasterPassword.isEmpty() || m_xStorageFile->getEncodedMasterPassword( aEncodedMP, aEncodedMPIV ) )
1166             bCanChangePassword = authorizateWithMasterPassword( aGuard, xTmpHandler );
1167
1168         if ( bCanChangePassword )
1169         {
1170             // ask for the new password, but do not set it
1171             OUString aPass = RequestPasswordFromUser( PasswordRequestMode_PASSWORD_CREATE, xTmpHandler );
1172
1173             if ( !aPass.isEmpty() )
1174             {
1175                 // get all the persistent entries if it is possible
1176                 const Sequence< UrlRecord > aPersistent = getAllPersistent( aGuard, uno::Reference< task::XInteractionHandler >() );
1177
1178                 // remove the master password and the entries persistence
1179                 removeMasterPassword(aGuard);
1180
1181                 // store the new master password
1182                 m_aMasterPassword = aPass;
1183                 std::vector< OUString > aMaster( 1, m_aMasterPassword );
1184                 OUString aIV = createIV();
1185                 m_xStorageFile->setEncodedMasterPassword(EncodePasswords(aMaster, aIV, m_aMasterPassword), aIV);
1186
1187                 // store all the entries with the new password
1188                 for ( const auto& rURL : aPersistent )
1189                     for ( const auto& rUser : rURL.UserList )
1190                         PrivateAdd( rURL.Url, rUser.UserName, rUser.Passwords, PERSISTENT_RECORD,
1191                                        uno::Reference< task::XInteractionHandler >() );
1192
1193                 bResult = true;
1194             }
1195         }
1196     }
1197
1198     return bResult;
1199 }
1200
1201 void SAL_CALL PasswordContainer::removeMasterPassword()
1202 {
1203     std::unique_lock aGuard(mMutex);
1204     removeMasterPassword(aGuard);
1205 }
1206
1207 void PasswordContainer::removeMasterPassword(std::unique_lock<std::mutex>& rGuard)
1208 {
1209     // remove all the stored passwords and the master password
1210     removeAllPersistent(rGuard);
1211
1212     if ( m_xStorageFile )
1213     {
1214         m_aMasterPassword.clear();
1215         m_xStorageFile->setEncodedMasterPassword( OUString(), OUString() ); // let the master password be removed from configuration
1216     }
1217 }
1218
1219 sal_Bool SAL_CALL PasswordContainer::hasMasterPassword(  )
1220 {
1221     std::unique_lock aGuard( mMutex );
1222
1223     if ( !m_xStorageFile )
1224         throw uno::RuntimeException();
1225
1226     OUString aEncodedMP, aEncodedMPIV;
1227     return ( m_xStorageFile->useStorage() && m_xStorageFile->getEncodedMasterPassword( aEncodedMP, aEncodedMPIV ) );
1228 }
1229
1230 sal_Bool SAL_CALL PasswordContainer::allowPersistentStoring( sal_Bool bAllow )
1231 {
1232     std::unique_lock aGuard( mMutex );
1233
1234     if ( !m_xStorageFile )
1235         throw uno::RuntimeException();
1236
1237     if ( !bAllow )
1238         removeMasterPassword(aGuard);
1239
1240     if (m_xStorageFile->useStorage() == static_cast<bool>(bAllow))
1241         return bAllow;
1242
1243     m_xStorageFile->setUseStorage( bAllow );
1244     return !bAllow;
1245 }
1246
1247 sal_Bool SAL_CALL PasswordContainer::isPersistentStoringAllowed()
1248 {
1249     std::unique_lock aGuard( mMutex );
1250
1251     if ( !m_xStorageFile )
1252         throw uno::RuntimeException();
1253
1254     return m_xStorageFile->useStorage();
1255 }
1256
1257 sal_Bool SAL_CALL PasswordContainer::useDefaultMasterPassword( const uno::Reference< task::XInteractionHandler >& xHandler )
1258 {
1259     bool bResult = false;
1260     uno::Reference< task::XInteractionHandler > xTmpHandler = xHandler;
1261     std::unique_lock aGuard( mMutex );
1262
1263     if ( m_xStorageFile && m_xStorageFile->useStorage() )
1264     {
1265         if ( !xTmpHandler.is() )
1266         {
1267             uno::Reference< lang::XMultiServiceFactory > xFactory( mComponent, uno::UNO_QUERY_THROW );
1268             uno::Reference< uno::XComponentContext > xContext( comphelper::getComponentContext(xFactory) );
1269             xTmpHandler.set( InteractionHandler::createWithParent(xContext, nullptr), uno::UNO_QUERY_THROW );
1270         }
1271
1272         bool bCanChangePassword = true;
1273         // if there is already a stored nondefault master password it should be entered by the user before the change happen
1274         OUString aEncodedMP, aEncodedMPIV;
1275         if( m_xStorageFile->getEncodedMasterPassword( aEncodedMP, aEncodedMPIV ) && !aEncodedMP.isEmpty() )
1276             bCanChangePassword = authorizateWithMasterPassword( aGuard, xTmpHandler );
1277
1278         if ( bCanChangePassword )
1279         {
1280             // generate the default password
1281             OUString aPass = GetDefaultMasterPassword();
1282             if ( !aPass.isEmpty() )
1283             {
1284                 // get all the persistent entries if it is possible
1285                 const Sequence< UrlRecord > aPersistent = getAllPersistent( aGuard, uno::Reference< task::XInteractionHandler >() );
1286
1287                 // remove the master password and the entries persistence
1288                 removeMasterPassword(aGuard);
1289
1290                 // store the empty string to flag the default master password
1291                 m_aMasterPassword = aPass;
1292                 m_xStorageFile->setEncodedMasterPassword( OUString(), OUString(), true );
1293
1294                 // store all the entries with the new password
1295                 for ( const auto& rURL : aPersistent )
1296                     for ( const auto& rUser : rURL.UserList )
1297                         PrivateAdd( rURL.Url, rUser.UserName, rUser.Passwords, PERSISTENT_RECORD,
1298                                    uno::Reference< task::XInteractionHandler >() );
1299
1300                 bResult = true;
1301             }
1302         }
1303     }
1304
1305     return bResult;
1306
1307 }
1308
1309 sal_Bool SAL_CALL PasswordContainer::isDefaultMasterPasswordUsed()
1310 {
1311     std::unique_lock aGuard( mMutex );
1312
1313     if ( !m_xStorageFile )
1314         throw uno::RuntimeException();
1315
1316     OUString aEncodedMP, aEncodedMPIV;
1317     return ( m_xStorageFile->useStorage() && m_xStorageFile->getEncodedMasterPassword( aEncodedMP, aEncodedMPIV ) && aEncodedMP.isEmpty() );
1318 }
1319
1320
1321 void SAL_CALL PasswordContainer::addUrl( const OUString& Url, sal_Bool MakePersistent )
1322 {
1323     mUrlContainer.add( Url, MakePersistent );
1324 }
1325
1326 OUString SAL_CALL PasswordContainer::findUrl( const OUString& Url )
1327 {
1328     return mUrlContainer.find( Url );
1329 }
1330
1331 void SAL_CALL PasswordContainer::removeUrl( const OUString& Url )
1332 {
1333     mUrlContainer.remove( Url );
1334 }
1335
1336 uno::Sequence< OUString > SAL_CALL PasswordContainer::getUrls( sal_Bool OnlyPersistent )
1337 {
1338     return mUrlContainer.list( OnlyPersistent );
1339 }
1340
1341
1342 void PasswordContainer::Notify()
1343 {
1344     std::unique_lock aGuard( mMutex );
1345
1346     // remove the cached persistent values in the memory
1347     for( auto& rEntry : m_aContainer )
1348     {
1349         for( std::vector< NamePasswordRecord >::iterator aNPIter = rEntry.second.begin(); aNPIter != rEntry.second.end(); )
1350         {
1351             if( aNPIter->HasPasswords( PERSISTENT_RECORD ) )
1352             {
1353                 aNPIter->RemovePasswords( PERSISTENT_RECORD );
1354
1355                 if ( m_xStorageFile )
1356                     m_xStorageFile->remove( rEntry.first, aNPIter->GetUserName() ); // remove record ( aURL, aName )
1357             }
1358
1359             if( !aNPIter->HasPasswords( MEMORY_RECORD ) )
1360             {
1361                 aNPIter = rEntry.second.erase(aNPIter);
1362             }
1363             else
1364                 ++aNPIter;
1365         }
1366     }
1367
1368     PasswordMap addon;
1369     if( m_xStorageFile )
1370         addon = m_xStorageFile->getInfo();
1371
1372     for( const auto& rEntry : addon )
1373     {
1374         PasswordMap::iterator aSearchIter = m_aContainer.find( rEntry.first );
1375         if( aSearchIter != m_aContainer.end() )
1376             for (auto const& aNP : rEntry.second)
1377                 UpdateVector( aSearchIter->first, aSearchIter->second, aNP, false );
1378         else
1379             m_aContainer.insert( PairUrlRecord( rEntry.first, rEntry.second ) );
1380     }
1381 }
1382
1383 OUString SAL_CALL PasswordContainer::getImplementationName(  )
1384 {
1385     return "stardiv.svl.PasswordContainer";
1386 }
1387
1388 sal_Bool SAL_CALL PasswordContainer::supportsService( const OUString& ServiceName )
1389 {
1390     return cppu::supportsService( this,  ServiceName );
1391 }
1392
1393 Sequence< OUString > SAL_CALL PasswordContainer::getSupportedServiceNames(  )
1394 {
1395     return { "com.sun.star.task.PasswordContainer" };
1396 }
1397
1398 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
1399 svl_PasswordContainer_get_implementation(
1400     css::uno::XComponentContext* context, css::uno::Sequence<css::uno::Any> const&)
1401 {
1402     return cppu::acquire(new PasswordContainer(context));
1403 }
1404
1405
1406 MasterPasswordRequest_Impl::MasterPasswordRequest_Impl( PasswordRequestMode Mode )
1407 {
1408     MasterPasswordRequest aRequest;
1409
1410     aRequest.Classification = InteractionClassification_ERROR;
1411     aRequest.Mode = Mode;
1412
1413     setRequest( Any( aRequest ) );
1414
1415     // Fill continuations...
1416     Sequence< RememberAuthentication > aRememberModes{ RememberAuthentication_NO };
1417
1418     m_xAuthSupplier
1419         = new ::ucbhelper::InteractionSupplyAuthentication(
1420                 this,
1421                 false, // bCanSetRealm
1422                 false,  // bCanSetUserName
1423                 true,  // bCanSetPassword
1424                 false, // bCanSetAccount
1425                 aRememberModes, // rRememberPasswordModes
1426                 RememberAuthentication_NO, // eDefaultRememberPasswordMode
1427                 aRememberModes, // rRememberAccountModes
1428                 RememberAuthentication_NO, // eDefaultRememberAccountMode
1429                 false // bCanUseSystemCredentials
1430             );
1431
1432     Sequence<
1433         Reference< XInteractionContinuation > > aContinuations{
1434             new ::ucbhelper::InteractionAbort( this ),
1435             new ::ucbhelper::InteractionRetry( this ),
1436             m_xAuthSupplier
1437     };
1438
1439     setContinuations( aContinuations );
1440 }
1441
1442
1443
1444 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */