pgpengine.cpp

#include "pgpengine.h"

#include <QDateTime>
#include <QFile>
#include <QProcess>
#include <QRegularExpression>

// ── helpers ──────────────────────────────────────────────

QString PGPEngine::findGpg() {
    static QString cached;
    if (!cached.isEmpty()) return cached;

    for (const auto &p : {"gpg2", "gpg",
                           "C:/Program Files (x86)/GnuPG/bin/gpg.exe",
                           "C:/Program Files/GnuPG/bin/gpg.exe"}) {
        QProcess proc;
        proc.start(QString(p), {"--version"});
        if (proc.waitForFinished(3000) && proc.exitCode() == 0) {
            cached = QString(p);
            return cached;
        }
    }
    cached = "gpg";
    return cached;
}

PGPEngine::Result PGPEngine::runGpg(const QStringList &args, const QString &stdinData) {
    QProcess proc;
    QStringList full = {"--batch", "--yes", "--no-tty"};
    full.append(args);

    proc.start(findGpg(), full);
    if (!proc.waitForStarted(5000))
        return {false, {}, "Failed to start GPG. Is GnuPG installed?"};

    if (!stdinData.isEmpty()) {
        proc.write(stdinData.toUtf8());
        proc.closeWriteChannel();
    }

    if (!proc.waitForFinished(60000)) {
        proc.kill();
        return {false, {}, "GPG timed out"};
    }

    QString out = QString::fromUtf8(proc.readAllStandardOutput());
    QString err = QString::fromUtf8(proc.readAllStandardError());

    if (proc.exitCode() != 0)
        return {false, out, err.isEmpty() ? "GPG returned error" : err};

    return {true, out, err};
}

// ── status ───────────────────────────────────────────────

bool PGPEngine::isGpgAvailable() {
    return runGpg({"--version"}).success;
}

QString PGPEngine::gpgVersion() {
    auto r = runGpg({"--version"});
    if (!r.success) return "Not available";
    return r.data.split('\n').value(0).trimmed();
}

// ── encrypt / decrypt ────────────────────────────────────

PGPEngine::Result PGPEngine::encrypt(const QString &plaintext, const QStringList &recipientKeyIds) {
    if (recipientKeyIds.isEmpty())
        return {false, {}, "No recipient specified"};

    QStringList args = {"--encrypt", "--armor", "--trust-model", "always"};
    for (const auto &k : recipientKeyIds)
        args << "--recipient" << k;

    return runGpg(args, plaintext);
}

PGPEngine::Result PGPEngine::decrypt(const QString &ciphertext) {
    return runGpg({"--decrypt"}, ciphertext);
}

PGPEngine::Result PGPEngine::encryptFile(const QString &inPath, const QString &outPath,
                                          const QStringList &recipients) {
    QStringList args = {"--encrypt", "--armor", "--trust-model", "always",
                        "--output", outPath};
    for (const auto &k : recipients)
        args << "--recipient" << k;
    args << inPath;
    return runGpg(args);
}

PGPEngine::Result PGPEngine::decryptFile(const QString &inPath, const QString &outPath) {
    return runGpg({"--decrypt", "--output", outPath, inPath});
}

// ── key listing ──────────────────────────────────────────

QList<PGPEngine::KeyInfo> PGPEngine::parseColonListing(const QString &output, const QString &keyType) {
    QList<KeyInfo> keys;
    KeyInfo current;
    bool haveCurrent = false;

    for (const auto &line : output.split('\n')) {
        QStringList fields = line.split(':');
        if (fields.size() < 10) continue;

        const QString &recType = fields[0];

        if (recType == keyType) {   // "pub" or "sec"
            if (haveCurrent) keys.append(current);
            current = KeyInfo();
            current.type = keyType;
            current.bits = fields[2].toInt();
            current.algorithm = fields[3];
            current.keyId = fields[4];

            if (!fields[5].isEmpty()) {
                qint64 ts = fields[5].toLongLong();
                current.created = QDateTime::fromSecsSinceEpoch(ts).toString("yyyy-MM-dd");
            }
            if (!fields[6].isEmpty()) {
                qint64 ts = fields[6].toLongLong();
                current.expires = QDateTime::fromSecsSinceEpoch(ts).toString("yyyy-MM-dd");
            }
            haveCurrent = true;
        } else if (recType == "uid" && haveCurrent) {
            if (current.userId.isEmpty())
                current.userId = fields[9];
        } else if (recType == "fpr" && haveCurrent) {
            if (current.fingerprint.isEmpty())
                current.fingerprint = fields[9];
        }
    }
    if (haveCurrent) keys.append(current);
    return keys;
}

QList<PGPEngine::KeyInfo> PGPEngine::listPublicKeys() {
    auto r = runGpg({"--list-keys", "--with-colons", "--with-fingerprint"});
    if (!r.success) return {};
    return parseColonListing(r.data, "pub");
}

QList<PGPEngine::KeyInfo> PGPEngine::listSecretKeys() {
    auto r = runGpg({"--list-secret-keys", "--with-colons", "--with-fingerprint"});
    if (!r.success) return {};
    return parseColonListing(r.data, "sec");
}

// ── key management ───────────────────────────────────────

PGPEngine::Result PGPEngine::importKey(const QString &keyData) {
    return runGpg({"--import"}, keyData);
}

PGPEngine::Result PGPEngine::importKeyFile(const QString &filePath) {
    return runGpg({"--import", filePath});
}

PGPEngine::Result PGPEngine::exportPublicKey(const QString &keyId) {
    return runGpg({"--export", "--armor", keyId});
}

PGPEngine::Result PGPEngine::deleteKey(const QString &fingerprint, bool secret) {
    if (secret)
        return runGpg({"--delete-secret-and-public-key", fingerprint});
    return runGpg({"--delete-keys", fingerprint});
}

PGPEngine::Result PGPEngine::generateKeyPair(const QString &name, const QString &email,
                                              const QString &passphrase,
                                              const QString &algo, int bits) {
    // Use unattended key generation with parameter block
    QString script;
    script += "%no-protection\n";
    if (!passphrase.isEmpty())
        script = "Passphrase: " + passphrase + "\n";

    script += "Key-Type: " + algo + "\n";
    script += "Key-Length: " + QString::number(bits) + "\n";
    script += "Subkey-Type: " + algo + "\n";
    script += "Subkey-Length: " + QString::number(bits) + "\n";
    script += "Name-Real: " + name + "\n";
    script += "Name-Email: " + email + "\n";
    script += "Expire-Date: 0\n";
    script += "%commit\n";

    return runGpg({"--gen-key"}, script);
}