sailfish-safe

safe.cpp (5685B)

---

 /*
  *   Copyright (C) 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 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 <https://www.gnu.org/licenses/>.
  */
 
 #include "safe.h"
 
 #include <QStandardPaths>
 #include <QProcess>
 #include <QIODevice>
 #include <QRegularExpression>
 #include <QRegularExpressionMatch>
 #include <QTimer>
 #include <QtConcurrent>
 #include <QFutureWatcher>
 
 #define SAFE_DIR "SAFE_DIR"
 #define SAFE_PID "SAFE_PID"
 #define SAFE_SOCK "SAFE_SOCK"
 #define SAFE_ASKPASS "SAFE_ASKPASS"
 
 namespace {
 } // namespace
 
 Safe::LockTask *Safe::lock()
 {
     return new LockTask();
 }
 
 Safe::UnlockTask *Safe::unlock(const QString &passphrase)
 {
     return new UnlockTask(passphrase);
 }
 
 Safe::EncryptTask *Safe::encrypt(const QString &file, const QString &content)
 {
     return new EncryptTask(file, content);
 }
 
 Safe::DecryptTask *Safe::decrypt(const QString &file)
 {
     return new DecryptTask(file);
 }
 
 
 Safe::Task::Task(QObject *parent)
     : QObject(parent)
 {
     QTimer::singleShot(0, this, &Task::start);
 }
 
 bool Safe::Task::error() const
 {
     return !mError.isNull();
 }
 
 QString Safe::Task::errorString() const
 {
     return mError;
 }
 
 void Safe::Task::setError(const QString &error)
 {
     mError = error;
 }
 
 void Safe::Task::start()
 {
     qDebug() << "Starting task" << this;
     auto future = QtConcurrent::run(this, &Task::run);
     auto *watcher = new QFutureWatcher<void>;
     connect(watcher, &QFutureWatcher<void>::finished, watcher, &QObject::deleteLater);
     connect(watcher, &QFutureWatcher<void>::finished, this, &Safe::Task::finished);
     connect(watcher, &QFutureWatcher<void>::finished, this, &QObject::deleteLater);
     watcher->setFuture(future);
 }
 
 Safe::LockTask::LockTask()
 {}
 
 void Safe::LockTask::run()
 {
     if (qEnvironmentVariableIsSet(SAFE_PID))
         return;
 
     const auto kill = QStandardPaths::findExecutable(QStringLiteral("kill"));
     const auto agent = QString::fromUtf8(qgetenv(SAFE_PID));
 
     QProcess process;
     process.setProgram(kill);
     process.setArguments({
         QStringLiteral("-USR1"),
         QStringLiteral("%1").arg(agent)
     });
     process.start();
     process.waitForStarted();
     process.waitForFinished();
     if (process.exitCode() != 0) {
         const auto err = process.readAllStandardError();
         qWarning() << "Failed to forget key:" << err;
         setError(QString::fromUtf8(err));
     }
 }
 
 Safe::UnlockTask::UnlockTask(const QString &passphrase)
     : mPassphrase(passphrase)
 {}
 
 void Safe::UnlockTask::run()
 {
     const QString safe = QStandardPaths::findExecutable(QStringLiteral("safe"));
 
     if (!qEnvironmentVariableIsSet(SAFE_PID)) {
         qWarning() << "Agent is not running";
         return;
     }
 
     if (!qEnvironmentVariableIsSet(SAFE_SOCK)) {
         qWarning() << "Agent is not reachable";
         return;
     }
 
     // Temporary hack until we can properly pass the passphrase to safe(1)
     // Expect the "askpass" command to be available and reading from stdin
     // ex. `read pass; echo $pass`
     qputenv(SAFE_ASKPASS, "/usr/local/bin/askpass");
 
     QProcess process;
     process.setProgram(safe);
     process.setArguments({
         QStringLiteral("-r"),
         QStringLiteral("-k")
     });
     process.start();
     process.waitForStarted();
     QThread::currentThread()->sleep(1);
     process.write(mPassphrase.toUtf8());
     process.write("\n");
     process.waitForFinished();
     if (process.exitCode() != 0) {
         const auto err = process.readAllStandardError();
         qWarning() << "Failed to unlock safe:" << err;
         setError(QString::fromUtf8(err));
     }
 }
 
 Safe::EncryptTask::EncryptTask(const QString &file, const QString &content)
     : mFile(file), mContent(content)
 {}
 
 void Safe::EncryptTask::run()
 {
     const QString safe = QStandardPaths::findExecutable(QStringLiteral("safe"));
     QProcess process;
     process.setProgram(safe);
     process.setArguments({
         QStringLiteral("-a"),
         QStringLiteral("%1").arg(mFile)
     });
     process.start();
     process.waitForStarted();
     process.write(mContent.toUtf8());
     process.closeWriteChannel();
     process.waitForFinished();
     if (process.exitCode() != 0) {
         const auto err = process.readAllStandardError();
         qWarning() << "Failed to encrypt data:" << err;
         setError(QString::fromUtf8(err));
     }
 }
 
 Safe::DecryptTask::DecryptTask(const QString &file)
     : Task(), mFile(file)
 {}
 
 QString Safe::DecryptTask::content() const
 {
     return mContent;
 }
 
 void Safe::DecryptTask::run()
 {
     const QString safe = QStandardPaths::findExecutable(QStringLiteral("safe"));
     QProcess process;
     process.setProgram(safe);
     process.setArguments({QStringLiteral("%1").arg(mFile)});
     process.start();
     process.waitForStarted();
     process.closeWriteChannel();
     process.waitForFinished();
     if (process.exitCode() != 0) {
         const auto err = process.readAllStandardError();
         qWarning() << "Failed to decrypt data:" << err;
         setError(QString::fromUtf8(err));
     } else {
         mContent = QString::fromUtf8(process.readAllStandardOutput());
     }
 }