sailfish-safe

passwordsmodel.cpp (7528B)

---

 /*
  *   Copyright (C) 2018  Daniel Vrátil <dvratil@kde.org>
  *                 2021  Willy Goiffon <contact@z3bra.org>
  *
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU Library General Public License as
  *   published by the Free Software Foundation; either version 2, 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 Library General Public
  *   License along with this program; if not, write to the
  *   Free Software Foundation, Inc.,
  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  */
 
 #include "passwordsmodel.h"
 #include "passwordprovider.h"
 #include "safe.h"
 
 #include <QDir>
 #include <QDebug>
 #include <QPointer>
 #include <QTemporaryFile>
 #include <QFile>
 
 #define SAFE_DIR "SAFE_DIR"
 
 class PasswordsModel::Node
 {
 public:
     Node() {}
 
     Node(const QString &name, PasswordsModel::EntryType type, Node *parent)
         : name(name), type(type), parent(parent)
     {
         if (parent) {
             parent->children.append(this);
         }
     }
 
     ~Node()
     {
         if (provider) {
             provider->expirePassword();
         }
         qDeleteAll(children);
     }
 
     QString path() const
     {
         if (!parent) {
             return name;
         } else {
             QString fileName = name;
             return parent->path() + QLatin1Char('/') + fileName;
         }
     }
 
     QString fullName() const
     {
         if (!mFullName.isNull()) {
             return mFullName;
         }
 
         if (!parent) {
             return {};
         }
         const auto p = parent->fullName();
         if (p.isEmpty()) {
             mFullName = name;
         } else {
             mFullName = p + QLatin1Char('/') + name;
         }
         return mFullName;
     }
 
     QString name;
     PasswordsModel::EntryType type;
     QPointer<PasswordProvider> provider;
     Node *parent = nullptr;
     QVector<Node*> children;
 
 private:
     mutable QString mFullName;
 };
 
 
 PasswordsModel::PasswordsModel(QObject *parent)
     : QAbstractItemModel(parent)
     , mWatcher(this)
 {
     if (qEnvironmentVariableIsSet(SAFE_DIR)) {
         mPassStore = QDir(QString::fromUtf8(qgetenv(SAFE_DIR)));
     } else {
         mPassStore = QDir(QStringLiteral("%1/.safe.d").arg(QDir::homePath()));
     }
 
     // FIXME: Try to figure out what has actually changed and update the model
     // accordingly instead of reseting it
     connect(&mWatcher, &QFileSystemWatcher::directoryChanged, this, &PasswordsModel::populate);
 
     populate();
 }
 
 PasswordsModel::~PasswordsModel()
 {
     delete mRoot;
 }
 
 PasswordsModel::Node *PasswordsModel::node(const QModelIndex& index) const
 {
     return static_cast<Node*>(index.internalPointer());
 }
 
 QHash<int, QByteArray> PasswordsModel::roleNames() const
 {
     return { { NameRole, "name" },
              { EntryTypeRole, "type" },
              { FullNameRole, "fullName" },
              { PathRole, "path" },
              { HasPasswordRole, "hasPassword" },
              { PasswordRole, "password" } };
 }
 
 int PasswordsModel::rowCount(const QModelIndex &parent) const
 {
     const auto parentNode = parent.isValid() ? node(parent) : mRoot;
     return parentNode ? parentNode->children.count() : 0;
 }
 
 int PasswordsModel::columnCount(const QModelIndex &parent) const
 {
     Q_UNUSED(parent)
     return 1;
 }
 
 QModelIndex PasswordsModel::index(int row, int column, const QModelIndex &parent) const
 {
     const auto parentNode = parent.isValid() ? node(parent) : mRoot;
     if (!parentNode || row < 0 || row >= parentNode->children.count() || column != 0) {
         return {};
     }
 
     return createIndex(row, column, parentNode->children.at(row));
 }
 
 QModelIndex PasswordsModel::parent(const QModelIndex &child) const
 {
     if (!child.isValid()) {
         return {};
     }
 
     const auto childNode = node(child);
     if (!childNode || !childNode->parent) {
         return {};
     }
     const auto parentNode = childNode->parent;
     if (parentNode == mRoot) {
         return {};
     }
     return createIndex(parentNode->parent->children.indexOf(parentNode), 0, parentNode);
 }
 
 QVariant PasswordsModel::data(const QModelIndex &index, int role) const
 {
     if (!index.isValid()) {
         return {};
     }
     const auto node = this->node(index);
     if (!node) {
         return {};
     }
 
     switch (role) {
     case Qt::DisplayRole:
         return node->name;
     case EntryTypeRole:
         return node->type;
     case PathRole:
         return node->path();
     case FullNameRole:
         return node->fullName();
     case PasswordRole:
         if (!node->provider) {
             node->provider = new PasswordProvider(node->fullName());
         }
         return QVariant::fromValue(node->provider.data());
     case HasPasswordRole:
         return !node->provider.isNull();
     }
 
     return {};
 }
 
 void PasswordsModel::populate()
 {
     beginResetModel();
     delete mRoot;
     mRoot = new Node;
     mRoot->name = mPassStore.absolutePath();
     populateDir(mPassStore, mRoot);
     endResetModel();
 }
 
 void PasswordsModel::populateDir(const QDir& dir, Node *parent)
 {
     mWatcher.addPath(dir.absolutePath());
     auto entries = dir.entryInfoList({ QStringLiteral("*") }, QDir::Files, QDir::NoSort);
     Q_FOREACH (const auto &entry, entries) {
         new Node(entry.completeBaseName(), PasswordEntry, parent);
     }
     entries = dir.entryInfoList(QDir::Dirs | QDir::NoDotAndDotDot, QDir::NoSort);
     Q_FOREACH (const auto &entry, entries) {
         auto node = new Node(entry.fileName(), FolderEntry, parent);
         populateDir(entry.absoluteFilePath(), node);
     }
 }
 
 // FIXME: This is absolutely not the right place for this piece of code
 // Should introduce PasswordManager to abstract password generation,
 // creation and access in an asynchronous manner.
 void PasswordsModel::addPassword(const QModelIndex &parent, const QString &name,
                                  const QString &password, const QString &extras)
 {
 
     QString data = password;
     QString secret = name;
     if (!extras.isEmpty()) {
         data += QStringLiteral("\n%1").arg(extras);
     }
 
     auto *task = Safe::encrypt(secret, data);
     connect(task, &Safe::EncryptTask::finished,
             this, [secret, task]() {
                 if (task->error())  {
                     qWarning() << "Error:" << task->errorString();
                     return;
                 }
                 qDebug() << "Successfully stored secret " << secret;
             });
 }
 
 void PasswordsModel::setPassphrase(const QString &passphrase)
 {
     auto *task = Safe::unlock(passphrase);
     connect(task, &Safe::UnlockTask::finished,
             this, [passphrase, task]() {
                 if (task->error())  {
                     qWarning() << "Error:" << task->errorString();
                     return;
                 }
                 qDebug() << "Safe unlocked!";
             });
 }
 
 void PasswordsModel::forgetPassphrase()
 {
     auto *task = Safe::lock();
     connect(task, &Safe::LockTask::finished,
             this, [task]() {
                 if (task->error())  {
                     qWarning() << "Error:" << task->errorString();
                     return;
                 }
                 qDebug() << "Safe locked!";
             });
 }