24939459383

Committed 25 Apr 2026 08:02PM UTC coverage: 26.827% (-0.8%) from 27.609%

Build # 24939459383

Build Type

Pull #1170

github

Committed by

web-flow

Commit Message

Merge db49679bc into 9048d2bb3

Pull Request Pull Request #1170: feat: add Import key dialog to UsersDialog for issue #1167

Coverage Stats

0 of 96 new or added lines in 3 files covered. (0.0%)

33 existing lines in 2 files now uncovered.

1722 of 6419 relevant lines covered (26.83%)

27.62 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/importkeydialog.cpp

// SPDX-FileCopyrightText: 2026 Anne Jan Brouwer
// SPDX-License-Identifier: GPL-3.0-or-later
#include "importkeydialog.h"

#include "executor.h"
#include "qtpasssettings.h"
#include "ui_importkeydialog.h"

#include <QApplication>
#include <QClipboard>
#include <QFile>
#include <QFileDialog>
#include <QMessageBox>
#include <QPlainTextEdit>
#include <QRegularExpression>
#include <QString>

static const QRegularExpression
    KEY_IMPORTED_EXACT(QStringLiteral(R"(gpg: key ([0-9A-Fa-f]+): imported)"));
static const QRegularExpression KEY_IMPORTED_GENERAL(
    QStringLiteral(R"(gpg: key ([0-9A-Fa-f]+):.*imported)"));

ImportKeyDialog::ImportKeyDialog(QWidget *parent)
    : QDialog(parent), ui(new Ui::ImportKeyDialog) {
  ui->setupUi(this);

  ui->inputTextEdit->setPlaceholderText(
      tr("Paste an ASCII-armored GPG key here..."));

  ui->importButton->setEnabled(false);
}

ImportKeyDialog::~ImportKeyDialog() = default;

QString ImportKeyDialog::importedKeyFingerprint() const {
  return m_importedKeyId;
}

void ImportKeyDialog::on_fileButton_clicked() {
  const QString fileName = QFileDialog::getOpenFileName(
      this, tr("Import GPG Key"), QString(),
      tr("GPG Key Files") + " (*.asc *.key);;" + tr("All Files") + " (*)");

  if (fileName.isEmpty()) {
    return;
  }

  QFile file(fileName);
  if (!file.open(QIODevice::ReadOnly)) {
    QMessageBox::warning(this, tr("Import Key"),
                         tr("Could not open file: %1").arg(fileName));
    return;
  }

  QByteArray bytes = file.readAll();
  file.close();

  ui->inputTextEdit->setPlainText(QString::fromUtf8(bytes));
}

void ImportKeyDialog::on_pasteButton_clicked() {
  QClipboard *clipboard = QApplication::clipboard();
  const QString text = clipboard->text();

  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 = QtPassSettings::getGpgExecutable();
  if (gpgExe.isEmpty()) {
    gpgExe = "gpg";
  }
  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;
}

QString ImportKeyDialog::parseGpgImportOutput(const QString &output) {
  const QStringList lines = output.split('\n', Qt::SkipEmptyParts);
  for (const QString &line : lines) {
    QRegularExpressionMatch match = KEY_IMPORTED_EXACT.match(line);
    if (match.hasMatch()) {
      return match.captured(1);
    }
    match = KEY_IMPORTED_GENERAL.match(line);
    if (match.hasMatch()) {
      return match.captured(1);
    }
  }
  return QString();
}

void ImportKeyDialog::showError(const QString &message) {
  QMessageBox::warning(this, tr("Import Key"), message);
}

void ImportKeyDialog::showSuccess(const QString &keyId) {
  QMessageBox::information(this, tr("Import Key"),
                           tr("Successfully imported key: %1").arg(keyId));
}

1	// SPDX-FileCopyrightText: 2026 Anne Jan Brouwer
2	// SPDX-License-Identifier: GPL-3.0-or-later
3	#include "importkeydialog.h"
4
5	#include "executor.h"
6	#include "qtpasssettings.h"
7	#include "ui_importkeydialog.h"
8
9	#include <QApplication>
10	#include <QClipboard>
11	#include <QFile>
12	#include <QFileDialog>
13	#include <QMessageBox>
14	#include <QPlainTextEdit>
15	#include <QRegularExpression>
16	#include <QString>
17
18	static const QRegularExpression
19	KEY_IMPORTED_EXACT(QStringLiteral(R"(gpg: key ([0-9A-Fa-f]+): imported)"));
20	static const QRegularExpression KEY_IMPORTED_GENERAL(
21	QStringLiteral(R"(gpg: key ([0-9A-Fa-f]+):.*imported)"));
22
NEW 23	ImportKeyDialog::ImportKeyDialog(QWidget *parent)	×
NEW 24	: QDialog(parent), ui(new Ui::ImportKeyDialog) {	×
NEW 25	ui->setupUi(this);	×
26
NEW 27	ui->inputTextEdit->setPlaceholderText(	×
NEW 28	tr("Paste an ASCII-armored GPG key here..."));	×
29
NEW 30	ui->importButton->setEnabled(false);	×
NEW 31	}	×
32
NEW 33	ImportKeyDialog::~ImportKeyDialog() = default;	×
34
NEW 35	QString ImportKeyDialog::importedKeyFingerprint() const {	×
NEW 36	return m_importedKeyId;	×
37	}
38
NEW 39	void ImportKeyDialog::on_fileButton_clicked() {	×
40	const QString fileName = QFileDialog::getOpenFileName(
NEW 41	this, tr("Import GPG Key"), QString(),	×
NEW 42	tr("GPG Key Files") + " (.asc .key);;" + tr("All Files") + " (*)");	×
43
NEW 44	if (fileName.isEmpty()) {	×
45	return;
46	}
47
NEW 48	QFile file(fileName);	×
NEW 49	if (!file.open(QIODevice::ReadOnly)) {	×
NEW 50	QMessageBox::warning(this, tr("Import Key"),	×
NEW 51	tr("Could not open file: %1").arg(fileName));	×
52	return;
53	}
54
NEW 55	QByteArray bytes = file.readAll();	×
NEW 56	file.close();	×
57
NEW 58	ui->inputTextEdit->setPlainText(QString::fromUtf8(bytes));	×
NEW 59	}	×
60
NEW 61	void ImportKeyDialog::on_pasteButton_clicked() {	×
NEW 62	QClipboard *clipboard = QApplication::clipboard();	×
NEW 63	const QString text = clipboard->text();	×
64
NEW 65	ui->inputTextEdit->setPlainText(text);	×
NEW 66	}	×
67
NEW 68	void ImportKeyDialog::on_importButton_clicked() {	×
NEW 69	const QString input = ui->inputTextEdit->toPlainText().trimmed();	×
NEW 70	if (input.isEmpty()) {	×
71	return;
72	}
73
NEW 74	if (importFromString(input)) {	×
NEW 75	accept();	×
76	}
77	}
78
NEW 79	void ImportKeyDialog::on_inputTextEdit_textChanged() {	×
NEW 80	const bool hasInput = !ui->inputTextEdit->toPlainText().trimmed().isEmpty();	×
NEW 81	ui->importButton->setEnabled(hasInput);	×
NEW 82	}	×
83
NEW 84	bool ImportKeyDialog::importFromString(const QString &input) {	×
NEW 85	QString gpgExe = QtPassSettings::getGpgExecutable();	×
NEW 86	if (gpgExe.isEmpty()) {	×
NEW 87	gpgExe = "gpg";	×
88	}
NEW 89	QStringList args = {"--status-fd", "1", "--import", "--batch", "--yes"};	×
90
NEW 91	QString stdOut;	×
NEW 92	QString stdErr;	×
93
NEW 94	int result = Executor::executeBlocking(gpgExe, args, input, &stdOut, &stdErr);	×
95
NEW 96	if (result != 0) {	×
NEW 97	showError(tr("GPG import failed:\n%1").arg(stdErr));	×
NEW 98	return false;	×
99	}
100
NEW 101	QString keyId = parseGpgImportOutput(stdOut);	×
NEW 102	if (keyId.isEmpty()) {	×
NEW 103	keyId = parseGpgImportOutput(stdErr);	×
104	}
105
NEW 106	if (keyId.isEmpty()) {	×
NEW 107	showError(tr("Could not parse imported key id from GPG output."));	×
NEW 108	return false;	×
109	}
110
NEW 111	m_importedKeyId = keyId;	×
NEW 112	showSuccess(keyId);	×
113	return true;
NEW 114	}	×
115
NEW 116	QString ImportKeyDialog::parseGpgImportOutput(const QString &output) {	×
NEW 117	const QStringList lines = output.split('\n', Qt::SkipEmptyParts);	×
NEW 118	for (const QString &line : lines) {	×
NEW 119	QRegularExpressionMatch match = KEY_IMPORTED_EXACT.match(line);	×
NEW 120	if (match.hasMatch()) {	×
NEW 121	return match.captured(1);	×
122	}
NEW 123	match = KEY_IMPORTED_GENERAL.match(line);	×
NEW 124	if (match.hasMatch()) {	×
NEW 125	return match.captured(1);	×
126	}
NEW 127	}	×
128	return QString();
129	}
130
NEW 131	void ImportKeyDialog::showError(const QString &message) {	×
NEW 132	QMessageBox::warning(this, tr("Import Key"), message);	×
NEW 133	}	×
134
NEW 135	void ImportKeyDialog::showSuccess(const QString &keyId) {	×
NEW 136	QMessageBox::information(this, tr("Import Key"),	×
NEW 137	tr("Successfully imported key: %1").arg(keyId));	×
NEW 138	}	×

IJHack / QtPass / 24939459383

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous