Libkleo

keyrequester.cpp
1/* -*- c++ -*-
2 keyrequester.cpp
3
4 This file is part of libkleopatra, the KDE keymanagement library
5 SPDX-FileCopyrightText: 2004 Klarälvdalens Datakonsult AB
6
7 Based on kpgpui.cpp
8 SPDX-FileCopyrightText: 2001, 2002 the KPGP authors
9 See file libkdenetwork/AUTHORS.kpgp for details
10
11 This file is part of KPGP, the KDE PGP/GnuPG support library.
12
13 SPDX-License-Identifier: GPL-2.0-or-later
14 */
15
16#include <config-libkleo.h>
17
18#include "keyrequester.h"
19
20#include "keyselectiondialog.h"
21
22#include <libkleo/algorithm.h>
23#include <libkleo/compliance.h>
24#include <libkleo/formatting.h>
25#include <libkleo/keyhelpers.h>
26
27#include <KLocalizedString>
28#include <KMessageBox>
29
30#include <QGpgME/KeyListJob>
31
32#include <QApplication>
33#include <QDialog>
34#include <QHBoxLayout>
35#include <QPushButton>
36#include <QString>
37
38#include <gpgme++/key.h>
39#include <gpgme++/keylistresult.h>
40
41using namespace QGpgME;
42using namespace Kleo;
43
44Kleo::KeyRequester::KeyRequester(unsigned int allowedKeys, bool multipleKeys, QWidget *parent)
45 : QWidget(parent)
46 , mOpenPGPBackend(nullptr)
47 , mSMIMEBackend(nullptr)
48 , mMulti(multipleKeys)
49 , mKeyUsage(allowedKeys)
50 , mJobs(0)
51 , d(nullptr)
52{
53 init();
54}
55
56Kleo::KeyRequester::KeyRequester(QWidget *parent)
57 : QWidget(parent)
58 , mOpenPGPBackend(nullptr)
59 , mSMIMEBackend(nullptr)
60 , mMulti(false)
61 , mKeyUsage(0)
62 , mJobs(0)
63 , d(nullptr)
64{
65 init();
66}
67
68void Kleo::KeyRequester::init()
69{
70 auto hlay = new QHBoxLayout(this);
71 hlay->setContentsMargins(0, 0, 0, 0);
72
73 if (DeVSCompliance::isCompliant()) {
74 mComplianceIcon = new QLabel{this};
75 mComplianceIcon->setPixmap(Formatting::questionIcon().pixmap(22));
76 }
77
78 // the label where the key id is to be displayed:
79 mLabel = new QLabel(this);
80 mLabel->setFrameStyle(QFrame::StyledPanel | QFrame::Sunken);
81
82 // the button to unset any key:
83 mEraseButton = new QPushButton(this);
84 mEraseButton->setAutoDefault(false);
85 mEraseButton->setSizePolicy(QSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum));
86 mEraseButton->setIcon(
87 QIcon::fromTheme(QApplication::isRightToLeft() ? QStringLiteral("edit-clear-locationbar-ltr") : QStringLiteral("edit-clear-locationbar-rtl")));
88 mEraseButton->setToolTip(i18nc("@info:tooltip", "Clear"));
89
90 // the button to call the KeySelectionDialog:
91 mDialogButton = new QPushButton(i18nc("@action:button", "Change..."), this);
92 mDialogButton->setAutoDefault(false);
93
94 if (mComplianceIcon) {
95 hlay->addWidget(mComplianceIcon);
96 }
97 hlay->addWidget(mLabel, 1);
98 hlay->addWidget(mEraseButton);
99 hlay->addWidget(mDialogButton);
100
101 connect(mEraseButton, &QPushButton::clicked, this, &SigningKeyRequester::slotEraseButtonClicked);
102 connect(mDialogButton, &QPushButton::clicked, this, &SigningKeyRequester::slotDialogButtonClicked);
103
104 setSizePolicy(QSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed));
105
106 setAllowedKeys(mKeyUsage);
107}
108
109Kleo::KeyRequester::~KeyRequester()
110{
111}
112
113const std::vector<GpgME::Key> &Kleo::KeyRequester::keys() const
114{
115 return mKeys;
116}
117
118const GpgME::Key &Kleo::KeyRequester::key() const
119{
120 static const GpgME::Key null = GpgME::Key::null;
121 if (mKeys.empty()) {
122 return null;
123 } else {
124 return mKeys.front();
125 }
126}
127
128void Kleo::KeyRequester::setKeys(const std::vector<GpgME::Key> &keys)
129{
130 mKeys.clear();
131 for (auto it = keys.begin(); it != keys.end(); ++it) {
132 if (!it->isNull()) {
133 mKeys.push_back(*it);
134 }
135 }
136 updateKeys();
137}
138
139void Kleo::KeyRequester::setKey(const GpgME::Key &key)
140{
141 mKeys.clear();
142 if (!key.isNull()) {
143 mKeys.push_back(key);
144 }
145 updateKeys();
146}
147
148QString Kleo::KeyRequester::fingerprint() const
149{
150 if (mKeys.empty()) {
151 return QString();
152 } else {
153 return QLatin1StringView(mKeys.front().primaryFingerprint());
154 }
155}
156
157QStringList Kleo::KeyRequester::fingerprints() const
158{
159 QStringList result;
160 for (auto it = mKeys.begin(); it != mKeys.end(); ++it) {
161 if (!it->isNull()) {
162 if (const char *fpr = it->primaryFingerprint()) {
163 result.push_back(QLatin1StringView(fpr));
164 }
165 }
166 }
167 return result;
168}
169
170void Kleo::KeyRequester::setFingerprint(const QString &fingerprint)
171{
172 startKeyListJob(QStringList(fingerprint));
173}
174
175void Kleo::KeyRequester::setFingerprints(const QStringList &fingerprints)
176{
177 startKeyListJob(fingerprints);
178}
179
180void Kleo::KeyRequester::updateKeys()
181{
182 if (mKeys.empty()) {
183 if (mComplianceIcon) {
184 mComplianceIcon->setPixmap(Formatting::unavailableIcon().pixmap(22));
185 mComplianceIcon->setToolTip(QString{});
186 }
187 mLabel->clear();
188 return;
189 }
190 if (mKeys.size() > 1) {
191 setMultipleKeysEnabled(true);
192 }
193
194 QStringList labelTexts;
195 QString toolTipText;
196 for (std::vector<GpgME::Key>::const_iterator it = mKeys.begin(); it != mKeys.end(); ++it) {
197 if (it->isNull()) {
198 continue;
199 }
200 const QString fpr = QLatin1StringView(it->primaryFingerprint());
201 const QString keyID = QString::fromLatin1(it->keyID());
202 labelTexts.push_back(keyID);
203 toolTipText += keyID + QLatin1StringView(": ");
204 if (const char *uid = it->userID(0).id()) {
205 if (it->protocol() == GpgME::OpenPGP) {
206 toolTipText += QString::fromUtf8(uid);
207 } else {
208 toolTipText += Formatting::prettyDN(uid);
209 }
210 } else {
211 toolTipText += xi18n("<placeholder>unknown</placeholder>");
212 }
213 toolTipText += QLatin1Char('\n');
214 }
215 if (mComplianceIcon) {
216 if (Kleo::all_of(mKeys, &Kleo::DeVSCompliance::keyIsCompliant)) {
217 mComplianceIcon->setPixmap(Formatting::successIcon().pixmap(22));
218 mComplianceIcon->setToolTip(DeVSCompliance::name(true));
219 } else {
220 mComplianceIcon->setPixmap(Formatting::warningIcon().pixmap(22));
221 mComplianceIcon->setToolTip(DeVSCompliance::name(false));
222 }
223 }
224 mLabel->setText(labelTexts.join(QLatin1StringView(", ")));
225 mLabel->setToolTip(toolTipText);
226}
227
228#ifndef __KLEO_UI_SHOW_KEY_LIST_ERROR_H__
229#define __KLEO_UI_SHOW_KEY_LIST_ERROR_H__
230static void showKeyListError(QWidget *parent, const GpgME::Error &err)
231{
232 Q_ASSERT(err);
233 const QString msg = i18n(
234 "<qt><p>An error occurred while fetching "
235 "the keys from the backend:</p>"
236 "<p><b>%1</b></p></qt>",
237 Formatting::errorAsString(err));
238
239 KMessageBox::error(parent, msg, i18nc("@title:window", "Key Listing Failed"));
240}
241#endif // __KLEO_UI_SHOW_KEY_LIST_ERROR_H__
242
243void Kleo::KeyRequester::startKeyListJob(const QStringList &fingerprints)
244{
245 if (!mSMIMEBackend && !mOpenPGPBackend) {
246 return;
247 }
248
249 mTmpKeys.clear();
250 mJobs = 0;
251
252 unsigned int count = 0;
253 for (QStringList::const_iterator it = fingerprints.begin(); it != fingerprints.end(); ++it) {
254 if (!(*it).trimmed().isEmpty()) {
255 ++count;
256 }
257 }
258
259 if (!count) {
260 // don't fall into the trap that an empty pattern means
261 // "return all keys" :)
262 setKey(GpgME::Key::null);
263 return;
264 }
265
266 if (mOpenPGPBackend) {
267 KeyListJob *job = mOpenPGPBackend->keyListJob(false); // local, no sigs
268 if (!job) {
269 KMessageBox::error(this,
270 i18n("The OpenPGP backend does not support listing keys. "
271 "Check your installation."),
272 i18nc("@title:window", "Key Listing Failed"));
273 } else {
274 connect(job, &KeyListJob::result, this, &SigningKeyRequester::slotKeyListResult);
275 connect(job, &KeyListJob::nextKey, this, &SigningKeyRequester::slotNextKey);
276
277 const GpgME::Error err =
278 job->start(fingerprints, mKeyUsage & Kleo::KeySelectionDialog::SecretKeys && !(mKeyUsage & Kleo::KeySelectionDialog::PublicKeys));
279
280 if (err) {
281 showKeyListError(this, err);
282 } else {
283 ++mJobs;
284 }
285 }
286 }
287
288 if (mSMIMEBackend) {
289 KeyListJob *job = mSMIMEBackend->keyListJob(false); // local, no sigs
290 if (!job) {
291 KMessageBox::error(this,
292 i18n("The S/MIME backend does not support listing keys. "
293 "Check your installation."),
294 i18nc("@title:window", "Key Listing Failed"));
295 } else {
296 connect(job, &KeyListJob::result, this, &SigningKeyRequester::slotKeyListResult);
297 connect(job, &KeyListJob::nextKey, this, &SigningKeyRequester::slotNextKey);
298
299 const GpgME::Error err =
300 job->start(fingerprints, mKeyUsage & Kleo::KeySelectionDialog::SecretKeys && !(mKeyUsage & Kleo::KeySelectionDialog::PublicKeys));
301
302 if (err) {
303 showKeyListError(this, err);
304 } else {
305 ++mJobs;
306 }
307 }
308 }
309
310 if (mJobs > 0) {
311 mEraseButton->setEnabled(false);
312 mDialogButton->setEnabled(false);
313 }
314}
315
316void Kleo::KeyRequester::slotNextKey(const GpgME::Key &key)
317{
318 if (!key.isNull()) {
319 mTmpKeys.push_back(key);
320 }
321}
322
323void Kleo::KeyRequester::slotKeyListResult(const GpgME::KeyListResult &res)
324{
325 if (res.error()) {
326 showKeyListError(this, res.error());
327 }
328
329 if (--mJobs <= 0) {
330 mEraseButton->setEnabled(true);
331 mDialogButton->setEnabled(true);
332
333 setKeys(mTmpKeys);
334 mTmpKeys.clear();
335 }
336}
337
338void Kleo::KeyRequester::slotDialogButtonClicked()
339{
340 KeySelectionDialog *dlg = mKeys.empty() ? new KeySelectionDialog(mDialogCaption, mDialogMessage, mInitialQuery, mKeyUsage, mMulti, false, this)
341 : new KeySelectionDialog(mDialogCaption, mDialogCaption, mKeys, mKeyUsage, mMulti, false, this);
342
343 if (dlg->exec() == QDialog::Accepted) {
344 if (mMulti) {
345 setKeys(dlg->selectedKeys());
346 } else {
347 setKey(dlg->selectedKey());
348 }
349 Q_EMIT changed();
350 }
351
352 delete dlg;
353}
354
355void Kleo::KeyRequester::slotEraseButtonClicked()
356{
357 if (!mKeys.empty()) {
358 Q_EMIT changed();
359 }
360 mKeys.clear();
361 updateKeys();
362}
363
364void Kleo::KeyRequester::setDialogCaption(const QString &caption)
365{
366 mDialogCaption = caption;
367}
368
369void Kleo::KeyRequester::setDialogMessage(const QString &msg)
370{
371 mDialogMessage = msg;
372}
373
374bool Kleo::KeyRequester::isMultipleKeysEnabled() const
375{
376 return mMulti;
377}
378
379void Kleo::KeyRequester::setMultipleKeysEnabled(bool multi)
380{
381 if (multi == mMulti) {
382 return;
383 }
384
385 if (!multi && !mKeys.empty()) {
386 mKeys.erase(mKeys.begin() + 1, mKeys.end());
387 }
388
389 mMulti = multi;
390 updateKeys();
391}
392
393unsigned int Kleo::KeyRequester::allowedKeys() const
394{
395 return mKeyUsage;
396}
397
398void Kleo::KeyRequester::setAllowedKeys(unsigned int keyUsage)
399{
400 mKeyUsage = keyUsage;
401 mOpenPGPBackend = nullptr;
402 mSMIMEBackend = nullptr;
403
404 if (mKeyUsage & KeySelectionDialog::OpenPGPKeys) {
405 mOpenPGPBackend = openpgp();
406 }
407 if (mKeyUsage & KeySelectionDialog::SMIMEKeys) {
408 mSMIMEBackend = smime();
409 }
410
411 if (mOpenPGPBackend && !mSMIMEBackend) {
412 mDialogCaption = i18n("OpenPGP Key Selection");
413 mDialogMessage = i18n("Please select an OpenPGP key to use.");
414 } else if (!mOpenPGPBackend && mSMIMEBackend) {
415 mDialogCaption = i18n("S/MIME Key Selection");
416 mDialogMessage = i18n("Please select an S/MIME key to use.");
417 } else {
418 mDialogCaption = i18n("Key Selection");
419 mDialogMessage = i18n("Please select an (OpenPGP or S/MIME) key to use.");
420 }
421}
422
423QPushButton *Kleo::KeyRequester::dialogButton()
424{
425 return mDialogButton;
426}
427
428QPushButton *Kleo::KeyRequester::eraseButton()
429{
430 return mEraseButton;
431}
432
433static inline unsigned int foo(bool openpgp, bool smime, bool trusted, bool valid)
434{
435 unsigned int result = 0;
436 if (openpgp) {
437 result |= Kleo::KeySelectionDialog::OpenPGPKeys;
438 }
439 if (smime) {
440 result |= Kleo::KeySelectionDialog::SMIMEKeys;
441 }
442 if (trusted) {
443 result |= Kleo::KeySelectionDialog::TrustedKeys;
444 }
445 if (valid) {
446 result |= Kleo::KeySelectionDialog::ValidKeys;
447 }
448 return result;
449}
450
451static inline unsigned int encryptionKeyUsage(bool openpgp, bool smime, bool trusted, bool valid)
452{
453 return foo(openpgp, smime, trusted, valid) | Kleo::KeySelectionDialog::EncryptionKeys | Kleo::KeySelectionDialog::PublicKeys;
454}
455
456static inline unsigned int signingKeyUsage(bool openpgp, bool smime, bool trusted, bool valid)
457{
458 return foo(openpgp, smime, trusted, valid) | Kleo::KeySelectionDialog::SigningKeys | Kleo::KeySelectionDialog::SecretKeys;
459}
460
461Kleo::EncryptionKeyRequester::EncryptionKeyRequester(bool multi, unsigned int proto, QWidget *parent, bool onlyTrusted, bool onlyValid)
462 : KeyRequester(encryptionKeyUsage(proto & OpenPGP, proto & SMIME, onlyTrusted, onlyValid), multi, parent)
463 , d(nullptr)
464{
465}
466
467Kleo::EncryptionKeyRequester::EncryptionKeyRequester(QWidget *parent)
468 : KeyRequester(0, false, parent)
469 , d(nullptr)
470{
471}
472
473Kleo::EncryptionKeyRequester::~EncryptionKeyRequester()
474{
475}
476
477void Kleo::EncryptionKeyRequester::setAllowedKeys(unsigned int proto, bool onlyTrusted, bool onlyValid)
478{
479 KeyRequester::setAllowedKeys(encryptionKeyUsage(proto & OpenPGP, proto & SMIME, onlyTrusted, onlyValid));
480}
481
482Kleo::SigningKeyRequester::SigningKeyRequester(bool multi, unsigned int proto, QWidget *parent, bool onlyTrusted, bool onlyValid)
483 : KeyRequester(signingKeyUsage(proto & OpenPGP, proto & SMIME, onlyTrusted, onlyValid), multi, parent)
484 , d(nullptr)
485{
486}
487
488Kleo::SigningKeyRequester::SigningKeyRequester(QWidget *parent)
489 : KeyRequester(0, false, parent)
490 , d(nullptr)
491{
492}
493
494Kleo::SigningKeyRequester::~SigningKeyRequester()
495{
496}
497
498void Kleo::SigningKeyRequester::setAllowedKeys(unsigned int proto, bool onlyTrusted, bool onlyValid)
499{
500 KeyRequester::setAllowedKeys(signingKeyUsage(proto & OpenPGP, proto & SMIME, onlyTrusted, onlyValid));
501}
502
503void Kleo::KeyRequester::virtual_hook(int, void *)
504{
505}
506void Kleo::EncryptionKeyRequester::virtual_hook(int id, void *data)
507{
508 KeyRequester::virtual_hook(id, data);
509}
510void Kleo::SigningKeyRequester::virtual_hook(int id, void *data)
511{
512 KeyRequester::virtual_hook(id, data);
513}
514
515#include "moc_keyrequester.cpp"
Kleo::KeyRequester
Base class for SigningKeyRequester and EncryptionKeyRequester.
Definition keyrequester.h:42
Kleo::KeyRequester::setFingerprint
void setFingerprint(const QString &fingerprint)
Set the key by fingerprint.
Definition keyrequester.cpp:170
Kleo::KeyRequester::setFingerprints
void setFingerprints(const QStringList &fingerprints)
Set the keys by fingerprint.
Definition keyrequester.cpp:175
Kleo::KeyRequester::setKeys
void setKeys(const std::vector< GpgME::Key > &keys)
Preferred method to set a key for multi-KeyRequesters.
Definition keyrequester.cpp:128
Kleo::KeyRequester::setKey
void setKey(const GpgME::Key &key)
Preferred method to set a key for non-multi-KeyRequesters.
Definition keyrequester.cpp:139
i18nc
QString i18nc(const char *context, const char *text, const TYPE &arg...)
xi18n
QString xi18n(const char *text, const TYPE &arg...)
i18n
QString i18n(const char *text, const TYPE &arg...)
KMessageBox::error
void error(QWidget *parent, const QString &text, const QString &title, const KGuiItem &buttonOk, Options options=Notify)
QCA::init
QCA_EXPORT void init()
QAbstractButton::clicked
void clicked(bool checked)
QDialog::exec
virtual int exec()
QGuiApplication::isRightToLeft
bool isRightToLeft()
QIcon::fromTheme
QIcon fromTheme(const QString &name)
QList::begin
iterator begin()
QList::end
iterator end()
QList::push_back
void push_back(parameter_type value)
QObject::connect
QMetaObject::Connection connect(const QObject *sender, PointerToMemberFunction signal, Functor functor)
QString::fromLatin1
QString fromLatin1(QByteArrayView str)
QString::fromUtf8
QString fromUtf8(QByteArrayView str)
QStringList::join
QString join(QChar separator) const const
QtFuture::connect
QFuture< ArgsType< Signal > > connect(Sender *sender, Signal signal)
QWidget::setSizePolicy
void setSizePolicy(QSizePolicy)
This file is part of the KDE documentation.
Documentation copyright © 1996-2025 The KDE developers.
Generated on Fri Apr 25 2025 11:49:03 by doxygen 1.13.2 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.