imitatepass.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2016 Anne Jan Brouwer
// SPDX-License-Identifier: GPL-3.0-or-later
#ifndef SRC_IMITATEPASS_H_
#define SRC_IMITATEPASS_H_
 
#include "gpgidsigner.h"
#include "nativegrep.h"
#include "pass.h"
#include "simpletransaction.h"
#include <QQueue>
#include <QTemporaryDir>
 
#include <atomic>
#include <memory>
#include <optional>
 
class QRegularExpression;
class QThread;

class ImitatePass : public Pass {
  Q_OBJECT
 
  friend class tst_util;
  friend class tst_imitatepass;
 
protected:
  auto gpgIdSigner() -> GpgIdSigner;
  auto loadVerifiedRecipients(const QString &gpgIdFile, QStringList *recipients,
                              QString *why = nullptr) -> bool;
  auto writeGpgIdFile(const QString &gpgIdFile, const QList<UserInfo> &users,
                      QByteArray *written = nullptr) -> bool;
  auto signGpgIdFile(const QString &gpgIdFile, const QByteArray &contents)
      -> bool;
  auto refuseLinkedGpgIdFolder(const QString &path) -> bool;
  auto recipientsForEntry(const QString &file, QStringList *recipients) -> bool;
  auto copyDestination(const QString &src, const QString &dest, bool force)
      -> QString;
  auto addGenerationHeader(const QString &gpgIdFile, const GpgIdSigner &signer,
                           QByteArray *contents) -> bool;
  auto settleSignature(const QString &gpgIdFile, const QByteArray &written,
                       const GpgIdSigner &signer, bool useGit,
                       QString *sigToCommit) -> bool;
  auto gitAddGpgId(const QString &gpgIdFile, const QString &gpgIdSigFile,
                   QString *out, QString *err) -> int;
  auto gitTracks(const QString &file) -> bool;
  auto commitArgs() -> QStringList;
  auto verifyGpgIdForDir(const QString &file,
                         QHash<QString, QStringList> &verified,
                         QStringList &gpgId) -> bool;
  auto createBackupCommit() -> bool;
  auto getKeysFromFile(const QString &fileName) -> QStringList;
  auto reencryptSingleFile(const QString &fileName,
                           const QStringList &recipients, QString *why) -> bool;
  auto decryptEntry(const QString &fileName, QString *plaintext) -> bool;
  auto encryptFor(const QString &output, const QStringList &recipients,
                  const QString &plaintext) -> bool;
  auto ciphertextHolds(const QString &ciphertext, const QString &plaintext)
      -> bool;
  auto commitReencrypted(const QString &fileName) -> bool;
  auto resolveMoveDestination(const QString &src, const QString &dest,
                              bool force) -> QString;
 
public:
  void executeMoveGit(const QString &src, const QString &destFile, bool force);

  void gitCommit(const QString &file, const QString &msg);

  void executeGit(PROCESS id, const QStringList &args,
                  QString input = QString(), bool readStdout = true,
                  bool readStderr = true);
  auto gitConfigured() const -> bool;
  auto gitReady() -> bool;
  void executeGpg(PROCESS id, const QStringList &args,
                  QString input = QString(), bool readStdout = true,
                  bool readStderr = true);

  class TransactionHelper {
    SimpleTransaction *m_transaction;
    PROCESS m_result;
 
  public:
    TransactionHelper(SimpleTransaction *trans, PROCESS result)
        : m_transaction(trans), m_result(result) {
      m_transaction->transactionStart();
    }

    ~TransactionHelper() { m_transaction->transactionEnd(m_result); }
  };
 
protected:
  QProcessEnvironment m_reencryptEnv;
  [[nodiscard]] auto execBlocking(const QString &app, const QStringList &args,
                                  const QString &input = QString(),
                                  QString *process_out = nullptr,
                                  QString *process_err = nullptr) -> int;
  [[nodiscard]] auto execBlocking(const QString &app, const QStringList &args,
                                  QString *process_out,
                                  QString *process_err = nullptr) -> int;
  auto storeGit(const QStringList &args, QString *out) -> bool override;
  void finished(int id, int exitCode, const QString &out,
                const QString &err) override;

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

  void beforeExecute(PROCESS id) override;
 
public:
  ImitatePass();
  ~ImitatePass() override;
 
  // Git operations
  void GitInit() override;
  void GitPull() override;
  void GitPull_b() override;
  void GitPush() override;
 
  // Password operations
  void Show(QString file) override;
  void Insert(QString file, QString newValue, bool overwrite) override;
  void Remove(QString file, bool isDir) override;
  void Init(QString path, const QList<UserInfo> &users) override;

  void reencryptPath(const QString &dir);
  void reencryptPath(const QString &dir, const AppSettings &settings);
  void cancelReencryptPath();
 
signals:
  void startReencryptPath();
  void endReencryptPath();
  void reencryptProgress(int current, int total);
 
  // Pass interface
public:
  void Move(const QString src, const QString dest, const bool force) override;
  void Copy(const QString src, const QString dest, const bool force) override;
  void Grep(QString pattern, bool caseInsensitive) override;
 
private:
  SimpleTransaction m_transaction;
  NativeGrep m_grep;
  QString m_transactionOutput;

  struct PendingInsert {
    std::shared_ptr<QTemporaryDir> scratch;
    QString output;
    QString file;
    bool overwrite = false;
  };

  QQueue<PendingInsert> m_pendingInserts;
  bool m_insertPlaced = false;

  auto placeEncryptedFile(const QString &output, const QString &file,
                          bool overwrite, QString *error) -> bool;

  struct ReencryptResult;
  bool m_reencryptActive = false;
  std::atomic<bool> m_reencryptCancel{false};
  QThread *m_reencryptThread = nullptr;
  void startReencryptWorker(const QString &dir);
  auto reencryptFiles(const QString &dir) -> ReencryptResult;
  auto pullBeforeReencrypt() -> bool;
  auto entriesToReencrypt(const QString &dir) -> QStringList;
  auto recipientsForDir(const QString &fileName,
                        QHash<QString, QStringList> &verified,
                        QStringList &gpgId, ReencryptResult &result) -> bool;
  auto recoverReencryptLeftovers(const QString &dir) -> bool;
  void dropStaleTemporary(const QString &path);
  auto restoreBackup(const QString &path) -> bool;
  void reportUnrestorable(const QString &path);
  void finishReencrypt(const ReencryptResult &result);

  struct UncommittedGpgId {
    QString folder;   
    QString gitError; 
  };

  std::optional<UncommittedGpgId> m_uncommittedGpgId;
  auto reencryptUsesGit() const -> bool;
  void reencryptWithoutGit(const QString &dir, const QString &gitError);
  void reportUncommittedGpgId(const QString &dir, const QString &gitError,
                              bool reencrypted);

  auto translatePathForWsl(const QString &path, const QString &exe) const
      -> QString;
  auto pgit(const QString &path) const -> QString;
  auto pgpg(const QString &path) const -> QString;
};
 
#endif // SRC_IMITATEPASS_H_