pass.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2016 Anne Jan Brouwer
// SPDX-License-Identifier: GPL-3.0-or-later
#ifndef SRC_PASS_H_
#define SRC_PASS_H_
 
#include "appsettings.h"
#include "enums.h"
#include "executor.h"
#include "gpgidgeneration.h"
#include "userinfo.h"
 
#include <QProcess>
#include <QProcessEnvironment>
#include <QQueue>
#include <QString>
#include <QStringList>
 
class GpgIdSigner;
#include <cassert>
#include <map>
#include <optional>

struct ResolvedGpgconfCommand {
  QString program;
  QStringList arguments;
};

class Pass : public QObject {
  Q_OBJECT

  bool wrapperRunning{false};
  QProcessEnvironment env;
 
protected:
  [[nodiscard]] auto storeEnvironment() const -> QProcessEnvironment {
    return withCurrentGitPin(env);
  }

  [[nodiscard]] auto withCurrentGitPin(QProcessEnvironment base) const
      -> QProcessEnvironment;

  AppSettings m_settings;
  Executor exec;

  using PROCESS = Enums::PROCESS;
 
public:
  Pass();
  void init(const AppSettings &settings);
  static bool gpgSupportsEd25519(const QString &gpgExecutable = {});
  static QString getDefaultKeyTemplate(const QString &gpgExecutable = {});
 
  ~Pass() override = default;
 
  // Git operations
  virtual void GitInit() = 0;
  virtual void GitPull() = 0;
  virtual void GitPull_b() = 0;
  virtual void GitPush() = 0;
 
  // Password operations
  virtual void Show(QString file) = 0;
  virtual void Insert(QString file, QString value, bool force) = 0;
  [[nodiscard]] auto insertsPending() const -> int { return m_insertsPending; }
  virtual void Remove(QString file, bool isDir) = 0;
  virtual void Move(const QString srcDir, const QString dest,
                    const bool force) = 0;
  virtual void Copy(const QString srcDir, const QString dest,
                    const bool force) = 0;
  virtual void Init(QString path, const QList<UserInfo> &users) = 0;
  virtual void Grep(QString pattern, bool caseInsensitive) = 0;

  virtual auto generatePassword(unsigned int length, const QString &charset)
      -> QString;
 
  // GPG operations
  void GenerateGPGKeys(QString batch);
  auto listKeys(QStringList keystrings, bool secret = false) -> QList<UserInfo>;
  auto listKeys(const QString &keystring = "", bool secret = false)
      -> QList<UserInfo>;
  void updateEnv();

  static constexpr qint64 kMaxPlaintextBytes = 64LL * 1024 * 1024;

  static auto maxOutputArgs() -> QStringList;
 
  // Static helpers
  static auto resolveGpgconfCommand(const QString &gpgPath)
      -> ResolvedGpgconfCommand;
  static auto getGpgIdPath(const QString &for_file, const QString &passStore)
      -> QString;
  static auto skippedGpgId(const QString &forFile, const QString &passStore,
                           QString *recordError = nullptr)
      -> std::optional<QString>;
  static auto getRecipientList(const QString &for_file,
                               const QString &passStore) -> QStringList;

  struct RecipientsForEditing {
    enum class State {
      Unsigned,
      Verified,
      VerifiedRollback,
      Rejected,
    };

    State state = State::Unsigned;
    QStringList recipients;
    QString warning;
  };

  auto recipientsForEditing(const QString &dir, const QString &passStore)
      -> RecipientsForEditing;
  static auto parseRecipients(const QByteArray &contents,
                              const QString &sourceName) -> QStringList;
  static auto loggableArgs(const QStringList &args) -> QStringList;
  static auto seedGpgIdFile(const QString &newDir, const QString &passStore)
      -> bool;

  [[nodiscard]] auto isIdle() const -> bool { return exec.isIdle(); }
 
protected:
  auto refuseSkippedGpgId(const QString &file, bool signing,
                          const QString &except = QString()) -> bool;

  auto verifySignedList(const GpgIdSigner &signer, const QString &gpgIdFile,
                        QByteArray *contents, QString *why) const -> bool;

  [[nodiscard]] virtual auto insertWritten(const QString &err) const -> bool {
    Q_UNUSED(err);
    return false;
  }

  void queueShow(const QString &file) { m_pendingShows.enqueue(file); }
  void queueInsert() { ++m_insertsPending; }
  enum class LinkScope {
    EntryAndParents,
    ParentsOnly,
  };

  enum class PathSpelling {
    Configured,
    PlacedByCaller,
  };

  auto refuseLinkedPath(const QString &path,
                        LinkScope scope = LinkScope::EntryAndParents,
                        PathSpelling spelling = PathSpelling::Configured)
      -> bool;
  auto refuseFolderOutsideStore(const QString &folder,
                                QString *relative = nullptr) -> bool;

  virtual auto storeGit(const QStringList &args, QString *out) -> bool {
    Q_UNUSED(args);
    Q_UNUSED(out);
    return false;
  }

  auto refuseUnfinishedGitOperation() -> bool;

  auto unfinishedGitOperationReason() -> QString;

  auto refusePendingPull() -> bool;

  void executeWrapper(PROCESS id, const QString &app, const QStringList &args,
                      bool readStdout = true, bool readStderr = true);
  auto generateRandomPassword(const QString &charset, unsigned int length)
      -> QString;
  auto boundedRandom(quint32 bound) -> quint32;
  void setEnvVar(const QString &name, const QString &value);

  void executeWrapper(PROCESS id, const QString &app, const QStringList &args,
                      QString input, bool readStdout, bool readStderr);
  virtual void beforeExecute(PROCESS id);
 
protected slots:
  virtual void finished(int id, int exitCode, const QString &out,
                        const QString &err);
 
private:
  QQueue<QString> m_pendingShows;
  int m_insertsPending = 0;
  void handleProcessError(PROCESS pid, int exitCode, const QString &out,
                          const QString &err);
  auto formatInsertError(const QString &friendly, const QString &err)
      -> QString;
  void emitProcessFinishedSignal(PROCESS pid, const QString &out,
                                 const QString &err);
  void refuseAsNotPartOfStore(const QString &why);
 
signals:
  void idle();
  void startingExecuteWrapper();
  void statusMsg(const QString &msg, int timeout);
  void critical(const QString &title, const QString &message);

  void processErrorExit(int exitCode, const QString &err);

  void finishedAnyWithPid(const QString &out, const QString &err,
                          Enums::PROCESS pid);
  void finishedGitInit(const QString &out, const QString &err);
  void finishedGitPull(const QString &out, const QString &err);
  void finishedGitPush(const QString &out, const QString &err);
  void finishedShow(const QString &out, const QString &file);
  void finishedInsert(const QString &out, const QString &err);
  void finishedRemove(const QString &out, const QString &err);
  void finishedInit(const QString &out, const QString &err);
  void finishedMove(const QString &out, const QString &err);
  void finishedCopy(const QString &out, const QString &err);
  void finishedGenerateGPGKeys(const QString &out, const QString &err);
  void generateGPGKeysFailed(const QString &err);
  void insertFailed(const QString &err, bool written);
  void finishedGrep(const QList<QPair<QString, QStringList>> &results);
};

QString gpgErrorMessage(const QString &err);
 
#endif // SRC_PASS_H_