File indexing completed on 2024-04-28 05:50:08

 /*
  * SPDX-License-Identifier: GPL-3.0-or-later
  * SPDX-FileCopyrightText: 2020 Johan Ouwerkerk <jm.ouwerkerk@gmail.com>
  */
 #include "accounts.h"
 
 #include "../logging_p.h"
 
 KEYSMITH_LOGGER(logger, ".model.accounts")
 
 namespace model
 {
     qint64 millisecondsLeftForToken(const QDateTime &epoch, uint timeStep, const std::function<qint64(void)> &clock)
     {
         QDateTime now = QDateTime::fromMSecsSinceEpoch(clock());
         if (!epoch.isValid() || !now.isValid() || timeStep == 0) {
             qCDebug(logger) << "Unable to compute milliseconds left: invalid arguments";
             return -1;
         }
 
         /*
          * Avoid integer overflow by casting to the wider type first before multiplying.
          * Not likely to happen 'in the wild', but good practice nevertheless
          */
         qint64 step = ((qint64) timeStep) * 1000LL;
 
         qint64 diff = epoch.msecsTo(now);
 
         /*
          * Compensate for the fact that % operator is not the same as mathematical mod in case diff is negative.
          * diff is negative when the given epoch is in the 'future' compared to the current clock value.
          */
         return diff < 0 ? - (diff % step) : step - (diff % step);
     }
 
     AccountView::AccountView(accounts::Account *model, QObject *parent) :
         QObject(parent), m_model(model)
     {
         QObject::connect(model, &accounts::Account::tokenChanged, this, &AccountView::tokenChanged);
         QObject::connect(this, &AccountView::remove, model, &accounts::Account::remove);
         QObject::connect(this, &AccountView::recompute, model, &accounts::Account::recompute);
         QObject::connect(this, &AccountView::advanceCounter, model, &accounts::Account::advanceCounter);
         QObject::connect(this, &AccountView::setCounter, model, &accounts::Account::setCounter);
     }
 
     bool AccountView::isHotp(void) const
     {
         return m_model->algorithm() == accounts::Account::Hotp;
     }
 
     bool AccountView::isTotp(void) const
     {
         return m_model->algorithm() == accounts::Account::Totp;
     }
 
     QString AccountView::name(void) const
     {
         return m_model->name();
     }
 
     QString AccountView::token(void) const
     {
         return m_model->token();
     }
 
     QString AccountView::issuer(void) const
     {
         return m_model->issuer();
     }
 
     quint64 AccountView::counter(void) const
     {
         return m_model->counter();
     }
 
     QDateTime AccountView::epoch(void) const
     {
         return m_model->epoch();
     }
 
     uint AccountView::timeStep(void) const
     {
         return m_model->timeStep();
     }
 
     uint AccountView::offset(void) const
     {
         return m_model->offset().value_or(0);
     }
 
     int AccountView::tokenLength(void) const
     {
         return m_model->tokenLength();
     }
 
     QString AccountView::hash(void) const
     {
         switch (m_model->hash()) {
         case accounts::Account::Sha1:
             return QStringLiteral("SHA1");
         case accounts::Account::Sha256:
             return QStringLiteral("SHA256");
         case accounts::Account::Sha512:
             return QStringLiteral("SHA512");
         }
         return QString();
     }
 
     qint64 AccountView::millisecondsLeftForToken(void) const
     {
         if (!isTotp()) {
             qCDebug(logger) << "Unable to compute milliseconds left for token, wrong account type:" << m_model->algorithm();
             return -1;
         }
 
         return model::millisecondsLeftForToken(m_model->epoch(), m_model->timeStep());
     }
 
     SimpleAccountListModel::SimpleAccountListModel(accounts::AccountStorage *storage, QObject *parent) :
         QAbstractListModel(parent), m_storage(storage), m_has_error(false), m_index(QVector<QString>())
     {
         QObject::connect(storage, &accounts::AccountStorage::added, this, &SimpleAccountListModel::added);
         QObject::connect(storage, &accounts::AccountStorage::removed, this, &SimpleAccountListModel::removed);
         QObject::connect(storage, &accounts::AccountStorage::error, this, &SimpleAccountListModel::handleError);
         QObject::connect(storage, &accounts::AccountStorage::loaded, this, &SimpleAccountListModel::loadedChanged);
 
         beginResetModel();
         const auto accounts = m_storage->accounts();
         for (const QString &name : accounts) {
             populate(name, createView(name));
         }
         m_has_error = storage->hasError();
         endResetModel();
     }
 
 
     AccountView * SimpleAccountListModel::createView(const QString &name)
     {
         accounts::Account * existingAccount = m_storage->get(name);
         if (!existingAccount) {
             qCDebug(logger) << "Account storage did not yield a valid account object for account name";
             return nullptr;
         }
 
         return new AccountView(existingAccount, this);
     }
 
     void SimpleAccountListModel::populate(const QString &name, AccountView *account)
     {
         if (!account) {
             qCDebug(logger) << "Not populating account without a valid account view object";
             return;
         }
 
         m_index.append(name);
         m_accounts[name] = account;
         Q_EMIT account->recompute();
     }
 
     bool SimpleAccountListModel::error(void) const
     {
         return m_has_error;
     }
 
     void SimpleAccountListModel::setError(bool markAsError)
     {
         if (!markAsError && m_storage->hasError()) {
             m_storage->clearError();
         }
 
         if (markAsError != m_has_error) {
             m_has_error = markAsError;
             Q_EMIT errorChanged();
         }
     }
 
     void SimpleAccountListModel::handleError(void)
     {
         setError(true);
     }
 
     bool SimpleAccountListModel::loaded(void) const
     {
         return m_storage->isLoaded();
     }
 
     accounts::Account::Hash SimpleAccountListModel::toHash(TOTPAlgorithms value)
     {
         switch (value) {
         case TOTPAlgorithms::Sha1:
             return accounts::Account::Hash::Sha1;
         case TOTPAlgorithms::Sha256:
             return accounts::Account::Hash::Sha256;
         case TOTPAlgorithms::Sha512:
             return accounts::Account::Hash::Sha512;
         default:
             Q_ASSERT_X(false, Q_FUNC_INFO, "Unknown/unsupported totp algorithm value");
             return accounts::Account::Hash::Sha1;
         }
     }
 
     void SimpleAccountListModel::addAccount(AccountInput *input)
     {
         if (!input) {
             qCDebug(logger) << "Not adding account, no input provided";
             return;
         }
         input->createNewAccount(m_storage);
     }
 
     QHash<int, QByteArray> SimpleAccountListModel::roleNames(void) const
     {
         QHash<int, QByteArray> roles;
         roles[NonStandardRoles::AccountRole] = "account";
         return roles;
     }
 
     QVariant SimpleAccountListModel::data(const QModelIndex &account, int role) const
     {
         if (!account.isValid()) {
             qCDebug(logger) << "Not returning any data, model index is invalid";
             return QVariant();
         }
 
         int accountIndex = account.row();
         if (accountIndex < 0 || m_index.size() < accountIndex) {
             qCDebug(logger) << "Not returning any data, model index is out of bounds:" << accountIndex
                 << "model size is:" << m_index.size();
             return QVariant();
         }
 
         if (role != NonStandardRoles::AccountRole) {
             qCDebug(logger) << "Not returning any data, unknown role:" << role;
             return QVariant();
         }
 
         const QString accountName = m_index.at(accountIndex);
         auto model = m_accounts.value(accountName, nullptr);
         if (!model) {
             qCDebug(logger) << "Not returning any data, unable to find associated account for:" << accountIndex;
             return QVariant();
         }
 
         return QVariant::fromValue(model);
     }
 
     int SimpleAccountListModel::rowCount(const QModelIndex &parent) const
     {
         return parent.isValid() ? 0 : m_index.size();
     }
 
     void SimpleAccountListModel::added(const QString &account)
     {
         auto newAccount = createView(account);
         if (!newAccount) {
             qCDebug(logger) << "Unable to handle added account: unable to construct account view object";
             return;
         }
 
         if (m_accounts.contains(account)) {
             qCDebug(logger) << "Added account already/still part of the model: requesting removal of the old one from the model first";
             removed(account);
         }
 
         int accountIndex = m_index.size();
         qCDebug(logger) << "Adding (new) account to the model at position:" << accountIndex;
 
         beginInsertRows(QModelIndex(), accountIndex, accountIndex);
         populate(account, newAccount);
         endInsertRows();
     }
 
     void SimpleAccountListModel::removed(const QString &account)
     {
         int accountIndex = m_index.indexOf(account);
         if (accountIndex < 0) {
             qCDebug(logger) << "Unable to handle account removal: account not part of the model";
             return;
         }
 
         AccountView *v = nullptr;
 
         qCDebug(logger) << "Removing (old) account from the model at position:" << accountIndex;
         beginRemoveRows(QModelIndex(), accountIndex, accountIndex);
         m_index.remove(accountIndex);
         v = m_accounts.take(account);
         endRemoveRows();
 
         if (v) {
             v->deleteLater();
         }
     }
 
     bool SimpleAccountListModel::isAccountStillAvailable(const QString &name, const QString &issuer) const
     {
         return m_storage && m_storage->isAccountStillAvailable(name, issuer);
     }
 
     AccountNameValidator::AccountNameValidator(QObject *parent) :
         QValidator(parent), m_validateAvailability(true), m_issuer(std::nullopt), m_accounts(nullptr), m_delegate(nullptr)
     {
     }
 
     bool AccountNameValidator::validateAvailability(void) const
     {
         return m_validateAvailability;
     }
 
     void AccountNameValidator::setValidateAvailability(bool enabled)
     {
         if (enabled != m_validateAvailability) {
             m_validateAvailability = enabled;
             Q_EMIT validateAvailabilityChanged();
         }
     }
 
     QString AccountNameValidator::issuer(void) const
     {
         return m_issuer
             ? *m_issuer
             : QStringLiteral(":: WARNING: dummy invalid issuer; this is meant as a write-only property anyway ::");
     }
 
     void AccountNameValidator::setIssuer(const QString &issuer)
     {
         if (m_issuer && issuer == *m_issuer) {
             qCDebug(logger) << "Ignoring new issuer: same as the current issuer";
             return;
         }
 
         m_issuer.emplace(issuer);
         Q_EMIT issuerChanged();
     }
 
     QValidator::State AccountNameValidator::validate(QString &input, int &pos) const
     {
         QValidator::State result = m_delegate.validate(input, pos);
         if (!m_validateAvailability) {
             qCDebug(logger) << "Not validating account availability: explicitly disabled";
             return result;
         }
 
         if (!m_accounts) {
             qCDebug(logger) << "Unable to validate account name: missing accounts model object";
             return QValidator::Invalid;
         }
 
         if (!m_issuer) {
             qCDebug(logger) << "Unable to validate account name: missing issuer";
             return QValidator::Invalid;
         }
 
         return result != QValidator::Acceptable || m_accounts->isAccountStillAvailable(input, *m_issuer)
             ? result
             : QValidator::Intermediate;
     }
 
     void AccountNameValidator::fixup(QString &input) const
     {
         m_delegate.fixup(input);
     }
 
     SimpleAccountListModel * AccountNameValidator::accounts(void) const
     {
         return m_accounts;
     }
 
     void AccountNameValidator::setAccounts(SimpleAccountListModel *accounts)
     {
         if (!accounts) {
             qCDebug(logger) << "Ignoring new accounts model: not a valid object";
             return;
         }
 
         m_accounts = accounts;
         Q_EMIT accountsChanged();
     }
 
     SortedAccountsListModel::SortedAccountsListModel(QObject *parent) : QSortFilterProxyModel(parent)
     {
     }
 
     void SortedAccountsListModel::setSourceModel(QAbstractItemModel *sourceModel)
     {
         SimpleAccountListModel *model = qobject_cast<SimpleAccountListModel*>(sourceModel);
         if (!model) {
             qCDebug(logger) << "Not setting source model: it is not an accounts list model!";
             return;
         }
 
         QSortFilterProxyModel::setSourceModel(sourceModel);
         qCDebug(logger) << "Updating properties & resorting the model";
         setSortRole(SimpleAccountListModel::NonStandardRoles::AccountRole);
         setDynamicSortFilter(true);
         setSortLocaleAware(true);
         sort(0);
     }
 
     bool SortedAccountsListModel::lessThan(const QModelIndex &source_left, const QModelIndex &source_right) const
     {
         QAbstractItemModel *source = sourceModel();
         Q_ASSERT_X(source, Q_FUNC_INFO, "should have a source model at this point");
 
         const SimpleAccountListModel *model = qobject_cast<const SimpleAccountListModel*>(source);
         // useless junk: implement sorting as no-op: claim equality between left & right
         if (!model) {
             qCDebug(logger) << "Short-circuiting lessThan operator: source model is not an accounts list model!";
             return false;
         }
 
         const QVariant leftValue = model->data(source_left, SimpleAccountListModel::NonStandardRoles::AccountRole);
         const QVariant rightValue = model->data(source_right, SimpleAccountListModel::NonStandardRoles::AccountRole);
 
         const AccountView * leftAccount = leftValue.isNull() ? nullptr : leftValue.value<AccountView*>();
         const AccountView * rightAccount = rightValue.isNull() ? nullptr : rightValue.value<AccountView*>();
 
         // useless junk: implement sorting as no-op: claim left == right
         if (!leftAccount && !rightAccount) {
             qCDebug(logger) << "Short-circuiting lessThan operator: both source model indices do not point to accounts";
             return false;
         }
 
         // Sort actual accounts before useless junk: claim left >= right
         if (!leftAccount) {
             qCDebug(logger) << "Short-circuiting lessThan operator: left source model index does not point to an account";
             return false;
         }
 
         // Sort actual accounts before useless junk: claim left < right
         if (!rightAccount) {
             qCDebug(logger) << "Short-circuiting lessThan operator: right source model index does not point to an account";
             return true;
         }
 
         const QString leftIssuer = leftAccount->issuer();
         const QString rightIssuer = rightAccount->issuer();
 
         // both issuers are null: sort by account name
         if (leftIssuer.isNull() && rightIssuer.isNull()) {
             return leftAccount->name().localeAwareCompare(rightAccount->name()) < 0;
         }
 
         // Sort accounts without issuer to the top: claim left < right
         if (leftIssuer.isNull()) {
             return true;
         }
 
         // Sort accounts without issuer to the top: claim left >= right
         if (rightIssuer.isNull()) {
             return false;
         }
 
         // actual sorting by account issuer, then name
         int issuer = leftIssuer.localeAwareCompare(rightIssuer);
         return issuer == 0 ? leftAccount->name().localeAwareCompare(rightAccount->name()) < 0 : issuer < 0;
     }
 }