File indexing completed on 2024-05-19 04:58:38

 /* ============================================================
 * Falkon - Qt web browser
 * Copyright (C) 2013-2018 David Rosca <nowrep@gmail.com>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 * ============================================================ */
 #include "passwordmanager.h"
 #include "passwordbackends/passwordbackend.h"
 #include "passwordbackends/databasepasswordbackend.h"
 #include "passwordbackends/databaseencryptedpasswordbackend.h"
 #include "settings.h"
 
 #include <QVector>
 #include <QDataStream>
 
 static const int passwordEntryVersion = 2;
 
 QDataStream &operator <<(QDataStream &stream, const PasswordEntry &entry)
 {
     stream << passwordEntryVersion;
     stream << entry.host;
     stream << entry.id;
     stream << entry.username;
     stream << entry.password;
     stream << entry.data;
     stream << entry.updated;
 
     return stream;
 }
 
 QDataStream &operator >>(QDataStream &stream, PasswordEntry &entry)
 {
     int version;
     stream >> version;
 
     if (version != passwordEntryVersion) {
         return stream;
     }
 
     stream >> entry.host;
     stream >> entry.id;
     stream >> entry.username;
     stream >> entry.password;
     stream >> entry.data;
     stream >> entry.updated;
 
     return stream;
 }
 
 PasswordManager::PasswordManager(QObject* parent)
     : QObject(parent)
     , m_loaded(false)
     , m_backend(nullptr)
     , m_databaseBackend(new DatabasePasswordBackend)
     , m_databaseEncryptedBackend(new DatabaseEncryptedPasswordBackend)
 {
     m_backends[QSL("database")] = m_databaseBackend;
     m_backends[QSL("database-encrypted")] = m_databaseEncryptedBackend;
 }
 
 void PasswordManager::loadSettings()
 {
     Settings settings;
     settings.beginGroup(QSL("PasswordManager"));
     QString backendId = settings.value(QSL("Backend"), QSL("database")).toString();
     settings.endGroup();
 
     if (m_backend) {
         m_backend->setActive(false);
     }
     m_backend = m_backends[m_backends.contains(backendId) ? backendId : QSL("database")];
     m_backend->setActive(true);
 }
 
 QStringList PasswordManager::getUsernames(const QUrl &url)
 {
     ensureLoaded();
     return m_backend->getUsernames(url);
 }
 
 QVector<PasswordEntry> PasswordManager::getEntries(const QUrl &url)
 {
     ensureLoaded();
     return m_backend->getEntries(url);
 }
 
 QVector<PasswordEntry> PasswordManager::getAllEntries()
 {
     ensureLoaded();
     return m_backend->getAllEntries();
 }
 
 void PasswordManager::addEntry(const PasswordEntry &entry)
 {
     ensureLoaded();
     m_backend->addEntry(entry);
 }
 
 bool PasswordManager::updateEntry(const PasswordEntry &entry)
 {
     ensureLoaded();
     return m_backend->updateEntry(entry);
 }
 
 void PasswordManager::updateLastUsed(PasswordEntry &entry)
 {
     ensureLoaded();
     m_backend->updateLastUsed(entry);
 }
 
 void PasswordManager::removeEntry(const PasswordEntry &entry)
 {
     ensureLoaded();
     m_backend->removeEntry(entry);
 }
 
 void PasswordManager::removeAllEntries()
 {
     ensureLoaded();
     m_backend->removeAll();
 }
 
 QHash<QString, PasswordBackend*> PasswordManager::availableBackends()
 {
     ensureLoaded();
     return m_backends;
 }
 
 PasswordBackend* PasswordManager::activeBackend()
 {
     ensureLoaded();
     return m_backend;
 }
 
 void PasswordManager::switchBackend(const QString &backendID)
 {
     PasswordBackend* backend = m_backends.value(backendID);
 
     if (!backend) {
         return;
     }
 
     if (m_backend) {
         m_backend->setActive(false);
     }
 
     m_backend = backend;
     m_backend->setActive(true);
 
     Settings settings;
     settings.beginGroup(QSL("PasswordManager"));
     settings.setValue(QSL("Backend"), backendID);
     settings.endGroup();
 
     Q_EMIT passwordBackendChanged();
 }
 
 bool PasswordManager::registerBackend(const QString &id, PasswordBackend* backend)
 {
     if (m_backends.contains(id)) {
         return false;
     }
 
     m_backends[id] = backend;
     return true;
 }
 
 void PasswordManager::unregisterBackend(PasswordBackend* backend)
 {
     const QString key = m_backends.key(backend);
     m_backends.remove(key);
 
     if (m_backend == backend) {
         m_backend = m_databaseBackend;
     }
 }
 
 QString PasswordManager::createHost(const QUrl &url)
 {
     QString host = url.host();
 
     if (host.isEmpty()) {
         host = url.toString();
     }
 
     if (url.port() != -1) {
         host.append(QLatin1Char(':'));
         host.append(QString::number(url.port()));
     }
 
     return host;
 }
 
 QByteArray PasswordManager::urlEncodePassword(const QString &password)
 {
     // Exclude space to properly decode to +
     QByteArray encodedPass = QUrl::toPercentEncoding(password, " ");
     encodedPass.replace(' ', '+'); // space has to be encoded to +
     encodedPass.replace('~', "%7E"); // ~ is unreserved char, needs to be manually encoded
     return encodedPass;
 }
 
 void PasswordManager::ensureLoaded()
 {
     if (!m_loaded) {
         loadSettings();
         m_loaded = true;
     }
 }
 
 PasswordManager::~PasswordManager()
 {
     delete m_databaseBackend;
     delete m_databaseEncryptedBackend;
 }