importkeydialog.cpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 Anne Jan Brouwer
// SPDX-License-Identifier: GPL-3.0-or-later
#include "importkeydialog.h"
#include "plainmessagebox.h"
#include "util.h"
 
#include "executor.h"
#include "ui_importkeydialog.h"
 
#include <QApplication>
#include <QClipboard>
#include <QFile>
#include <QFileDialog>
#include <QFileInfo>
#include <QMessageBox>
#include <QPlainTextEdit>
#include <QRegularExpression>
#include <QString>
 
// Locale-independent: gpg's machine-readable status output via --status-fd 1.
// See doc/DETAILS in the GnuPG source for IMPORT_OK / IMPORTED grammar.
// Doxygen reads `Type name(args);` as a function, so these three constants
// are hidden from it and described here instead.
// `[GNUPG:] IMPORT_OK <reason> <fingerprint>`: captures the full fingerprint,
// the preferred identifier.
static const QRegularExpression
    IMPORT_OK_RE(QStringLiteral(R"(\‍[GNUPG:\‍] IMPORT_OK \d+ ([0-9A-Fa-f]+))"));
// `[GNUPG:] IMPORTED <keyid> <userid>`: captures the 16-hex long key id, tried
// after IMPORT_OK_RE.
static const QRegularExpression
    IMPORTED_RE(QStringLiteral(R"(\‍[GNUPG:\‍] IMPORTED ([0-9A-Fa-f]{16}))"));
// Fallback for the human-readable (English-locale) `gpg: key <id>: ...
// imported` line, last resort when no status line was seen.
static const QRegularExpression KEY_IMPORTED_FALLBACK(
    QStringLiteral(R"(gpg: key ([0-9A-Fa-f]{40}|[0-9A-Fa-f]{16}):.*imported)"));
 
ImportKeyDialog::ImportKeyDialog(const QString &gpgExe, QWidget *parent)
    : QDialog(parent), ui(new Ui::ImportKeyDialog), m_gpgExe(gpgExe) {
  ui->setupUi(this);
  ui->importButton->setEnabled(false);
}
 
ImportKeyDialog::~ImportKeyDialog() = default;
 
auto ImportKeyDialog::importedKeyId() const -> QString {
  return m_importedKeyId;
}
 
void ImportKeyDialog::on_fileButton_clicked() {
  const QString fileName = QFileDialog::getOpenFileName(
      this, tr("Import GPG key"), QString(),
      tr("ASCII-armored GPG key") + " (*.asc);;" + tr("All files") + " (*)");
 
  if (fileName.isEmpty()) {
    return;
  }
 
  // A key file, so a regular one of sensible size: a FIFO would block the
  // GUI and /dev/zero (or a sparse file) would be read without end.
  constexpr qint64 kMaxKeyFileBytes = 16LL * 1024 * 1024;
  // A link is followed, deliberately: the user picked this file, unlike a
  // name found in the store. Its target is then opened as the regular file
  // it is at the moment of the open, without blocking: a FIFO swapped in
  // after the pick would otherwise hang the GUI waiting for a writer.
  QFile file;
  const QString target = QFileInfo(fileName).canonicalFilePath();
  if (target.isEmpty() || !Util::openRegularFile(target, file)) {
    PlainMessageBox::warning(this, tr("Import key"),
                             tr("Could not open file: %1").arg(fileName));
    return;
  }
 
  // The size first, so a large file is not read at all; the read limit
  // still guards one that grows meanwhile.
  const bool tooLarge = file.size() > kMaxKeyFileBytes;
  const QByteArray bytes =
      tooLarge ? QByteArray() : file.read(kMaxKeyFileBytes + 1);
  file.close();
  if (tooLarge || bytes.size() > kMaxKeyFileBytes) {
    PlainMessageBox::warning(
        this, tr("Import key"),
        tr("%1 is larger than a key file can be.").arg(fileName));
    return;
  }
 
  // Only ASCII-armored content is shown in the text edit; binary keyrings
  // would lose bytes through UTF-8 conversion. Reject anything that doesn't
  // start with the PGP armor header.
  if (!bytes.trimmed().startsWith("-----BEGIN PGP")) {
    // Message body is rich text (uses <code>/<b>); escape the path so any
    // characters in it cannot reach the HTML subset Qt renders.
    QMessageBox::warning(
        this, tr("Import key"),
        tr("%1 does not look like an ASCII-armored GPG key. Convert it with "
           "<code>gpg --armor --export</code> first, or paste the armored "
           "block via <b>From clipboard</b>.")
            .arg(fileName.toHtmlEscaped()));
    return;
  }
 
  ui->inputTextEdit->setPlainText(QString::fromUtf8(bytes));
}
 
void ImportKeyDialog::on_pasteButton_clicked() {
  const QClipboard *clipboard = QApplication::clipboard();
  const QString text = clipboard->text();
  if (text.isEmpty()) {
    // Don't wipe whatever the user already typed/loaded for an empty
    // clipboard.
    return;
  }
  ui->inputTextEdit->setPlainText(text);
}
 
void ImportKeyDialog::on_importButton_clicked() {
  const QString input = ui->inputTextEdit->toPlainText().trimmed();
  if (input.isEmpty()) {
    return;
  }
 
  if (importFromString(input)) {
    accept();
  }
}
 
void ImportKeyDialog::on_inputTextEdit_textChanged() {
  const bool hasInput = !ui->inputTextEdit->toPlainText().trimmed().isEmpty();
  ui->importButton->setEnabled(hasInput);
}
 
bool ImportKeyDialog::importFromString(const QString &input) {
  QString gpgExe = m_gpgExe.isEmpty() ? QStringLiteral("gpg") : m_gpgExe;
  QStringList args = {"--status-fd", "1", "--import", "--batch", "--yes"};
 
  QString stdOut;
  QString stdErr;
 
  int result = Executor::executeBlocking(gpgExe, args, input, &stdOut, &stdErr);
 
  if (result != 0) {
    showError(tr("GPG import failed:\n%1").arg(stdErr));
    return false;
  }
 
  QString keyId = parseGpgImportOutput(stdOut);
  if (keyId.isEmpty()) {
    keyId = parseGpgImportOutput(stdErr);
  }
 
  if (keyId.isEmpty()) {
    showError(tr("Could not parse imported key id from GPG output."));
    return false;
  }
 
  m_importedKeyId = keyId;
  showSuccess(keyId);
  return true;
}
 
auto ImportKeyDialog::parseGpgImportOutput(const QString &output) -> QString {
  const QStringList lines = output.split('\n', Qt::SkipEmptyParts);
  // The order here is the priority order: prefer the locale-independent
  // status lines over the English human-readable line, and within the
  // status lines prefer IMPORT_OK (full fingerprint) over IMPORTED
  // (long key id). Each regex is scanned across every line before we
  // fall through to the next regex; the per-line ordering of gpg's
  // output (which emits IMPORTED before IMPORT_OK) must not pick the
  // weaker identifier.
  for (const QString &line : lines) {
    const QRegularExpressionMatch match = IMPORT_OK_RE.match(line);
    if (match.hasMatch()) {
      return match.captured(1);
    }
  }
  for (const QString &line : lines) {
    const QRegularExpressionMatch match = IMPORTED_RE.match(line);
    if (match.hasMatch()) {
      return match.captured(1);
    }
  }
  for (const QString &line : lines) {
    const QRegularExpressionMatch match = KEY_IMPORTED_FALLBACK.match(line);
    if (match.hasMatch()) {
      return match.captured(1);
    }
  }
  return {};
}
 
void ImportKeyDialog::showError(const QString &message) {
  // gpg's stderr quotes user IDs ("Name <a@b>"): plain, so they show as
  // written and cannot be markup.
  PlainMessageBox::warning(this, tr("Import key"), message);
}
 
void ImportKeyDialog::showSuccess(const QString &keyId) {
  QMessageBox::information(this, tr("Import key"),
                           tr("Public key %1 imported. Check its fingerprint "
                              "with its owner before encrypting to it: "
                              "importing a key says nothing about who holds "
                              "it.")
                               .arg(keyId));
}