1 /*
2 defaultkeyfilter.cpp
3
4 This file is part of libkleopatra, the KDE keymanagement library
5 SPDX-FileCopyrightText: 2004 Klarälvdalens Datakonsult AB
6
7 SPDX-FileCopyrightText: 2016 Bundesamt für Sicherheit in der Informationstechnik
8 SPDX-FileContributor: Intevation GmbH
9
10 SPDX-License-Identifier: GPL-2.0-or-later
11 */
12
13 #include "defaultkeyfilter.h"
14
15 #include "utils/formatting.h"
16
17 #include <functional>
18 #include <memory>
19
20 using namespace GpgME;
21 using namespace Kleo;
22
is_card_key(const Key & key)23 static bool is_card_key(const Key &key)
24 {
25 const std::vector<Subkey> sks = key.subkeys();
26 return std::find_if(sks.begin(), sks.end(),
27 std::mem_fn(&Subkey::isCardKey)) != sks.end();
28 }
29
30 class DefaultKeyFilter::Private
31 {
32
33 public:
Private()34 Private() :
35 mMatchContexts(AnyMatchContext),
36 mRevoked(DoesNotMatter),
37 mExpired(DoesNotMatter),
38 mInvalid(DoesNotMatter),
39 mDisabled(DoesNotMatter),
40 mRoot(DoesNotMatter),
41 mCanEncrypt(DoesNotMatter),
42 mCanSign(DoesNotMatter),
43 mCanCertify(DoesNotMatter),
44 mCanAuthenticate(DoesNotMatter),
45 mQualified(DoesNotMatter),
46 mCardKey(DoesNotMatter),
47 mHasSecret(DoesNotMatter),
48 mIsOpenPGP(DoesNotMatter),
49 mWasValidated(DoesNotMatter),
50 mIsDeVs(DoesNotMatter),
51 mBad(DoesNotMatter),
52 mOwnerTrust(LevelDoesNotMatter),
53 mOwnerTrustReferenceLevel(Key::Unknown),
54 mValidity(LevelDoesNotMatter),
55 mValidityReferenceLevel(UserID::Unknown)
56 {}
57 QColor mFgColor, mBgColor;
58 QString mName;
59 QString mIcon;
60 QString mId;
61 MatchContexts mMatchContexts;
62 unsigned int mSpecificity = 0;
63 bool mItalic = false;
64 bool mBold = false;
65 bool mStrikeOut = false;
66 bool mUseFullFont = false;
67 QFont mFont;
68
69 TriState mRevoked;
70 TriState mExpired;
71 TriState mInvalid;
72 TriState mDisabled;
73 TriState mRoot;
74 TriState mCanEncrypt;
75 TriState mCanSign;
76 TriState mCanCertify;
77 TriState mCanAuthenticate;
78 TriState mQualified;
79 TriState mCardKey;
80 TriState mHasSecret;
81 TriState mIsOpenPGP;
82 TriState mWasValidated;
83 TriState mIsDeVs;
84 TriState mBad;
85
86 LevelState mOwnerTrust;
87 GpgME::Key::OwnerTrust mOwnerTrustReferenceLevel;
88 LevelState mValidity;
89 GpgME::UserID::Validity mValidityReferenceLevel;
90
91 };
92
DefaultKeyFilter()93 DefaultKeyFilter::DefaultKeyFilter()
94 : KeyFilter(),
95 d_ptr(new Private())
96 {
97 }
98
~DefaultKeyFilter()99 DefaultKeyFilter::~DefaultKeyFilter() {}
100
matches(const Key & key,MatchContexts contexts) const101 bool DefaultKeyFilter::matches(const Key &key, MatchContexts contexts) const
102 {
103 if (!(d_ptr->mMatchContexts & contexts)) {
104 return false;
105 }
106 #ifdef MATCH
107 #undef MATCH
108 #endif
109 #define MATCH(member,method) \
110 if ( member != DoesNotMatter && key.method() != bool( member == Set ) ) \
111 return false
112 #define IS_MATCH(what) MATCH( d_ptr->m##what, is##what )
113 #define CAN_MATCH(what) MATCH( d_ptr->mCan##what, can##what )
114 IS_MATCH(Revoked);
115 IS_MATCH(Expired);
116 IS_MATCH(Invalid);
117 IS_MATCH(Disabled);
118 IS_MATCH(Root);
119 CAN_MATCH(Encrypt);
120 CAN_MATCH(Sign);
121 CAN_MATCH(Certify);
122 CAN_MATCH(Authenticate);
123 IS_MATCH(Qualified);
124 if (d_ptr->mCardKey != DoesNotMatter) {
125 if ((d_ptr->mCardKey == Set && !is_card_key(key)) ||
126 (d_ptr->mCardKey == NotSet && is_card_key(key))) {
127 return false;
128 }
129 }
130 MATCH(d_ptr->mHasSecret, hasSecret);
131 #undef MATCH
132 if (d_ptr->mIsOpenPGP != DoesNotMatter &&
133 bool(key.protocol() == GpgME::OpenPGP) != bool(d_ptr->mIsOpenPGP == Set)) {
134 return false;
135 }
136 if (d_ptr->mWasValidated != DoesNotMatter &&
137 bool(key.keyListMode() & GpgME::Validate) != bool(d_ptr->mWasValidated == Set)) {
138 return false;
139 }
140 if (d_ptr->mIsDeVs != DoesNotMatter &&
141 bool(Formatting::uidsHaveFullValidity(key) && Formatting::isKeyDeVs(key)) != bool(d_ptr->mIsDeVs == Set)) {
142 return false;
143 }
144 if (d_ptr->mBad != DoesNotMatter &&
145 /* This is similar to GPGME::Key::isBad which was introduced in GPGME 1.13.0 */
146 bool(key.isNull() || key.isRevoked() || key.isExpired() || key.isDisabled() || key.isInvalid()) != bool(d_ptr->mBad == Set)) {
147 return false;
148 }
149 switch (d_ptr->mOwnerTrust) {
150 default:
151 case LevelDoesNotMatter:
152 break;
153 case Is:
154 if (key.ownerTrust() != d_ptr->mOwnerTrustReferenceLevel) {
155 return false;
156 }
157 break;
158 case IsNot:
159 if (key.ownerTrust() == d_ptr->mOwnerTrustReferenceLevel) {
160 return false;
161 }
162 break;
163 case IsAtLeast:
164 if (static_cast<int>(key.ownerTrust()) < static_cast<int>(d_ptr->mOwnerTrustReferenceLevel)) {
165 return false;
166 }
167 break;
168 case IsAtMost:
169 if (static_cast<int>(key.ownerTrust()) > static_cast<int>(d_ptr->mOwnerTrustReferenceLevel)) {
170 return false;
171 }
172 break;
173 }
174 const UserID uid = key.userID(0);
175 switch (d_ptr->mValidity) {
176 default:
177 case LevelDoesNotMatter:
178 break;
179 case Is:
180 if (uid.validity() != d_ptr->mValidityReferenceLevel) {
181 return false;
182 }
183 break;
184 case IsNot:
185 if (uid.validity() == d_ptr->mValidityReferenceLevel) {
186 return false;
187 }
188 break;
189 case IsAtLeast:
190 if (static_cast<int>(uid.validity()) < static_cast<int>(d_ptr->mValidityReferenceLevel)) {
191 return false;
192 }
193 break;
194 case IsAtMost:
195 if (static_cast<int>(uid.validity()) > static_cast<int>(d_ptr->mValidityReferenceLevel)) {
196 return false;
197 }
198 break;
199 }
200 return true;
201 }
202
fontDescription() const203 KeyFilter::FontDescription DefaultKeyFilter::fontDescription() const
204 {
205 if (d_ptr->mUseFullFont) {
206 return FontDescription::create(font(), bold(), italic(), strikeOut());
207 } else {
208 return FontDescription::create(bold(), italic(), strikeOut());
209 }
210 }
211
setFgColor(const QColor & value) const212 void DefaultKeyFilter::setFgColor(const QColor &value) const
213 {
214 d_ptr->mFgColor = value;
215 }
216
setBgColor(const QColor & value) const217 void DefaultKeyFilter::setBgColor(const QColor &value) const
218 {
219 d_ptr->mBgColor = value;
220 }
221
setName(const QString & value) const222 void DefaultKeyFilter::setName(const QString &value) const
223 {
224 d_ptr->mName = value;
225 }
226
setIcon(const QString & value) const227 void DefaultKeyFilter::setIcon(const QString &value) const
228 {
229 d_ptr->mIcon = value;
230 }
231
setId(const QString & value) const232 void DefaultKeyFilter::setId(const QString &value) const
233 {
234 d_ptr->mId = value;
235 }
236
setMatchContexts(MatchContexts value) const237 void DefaultKeyFilter::setMatchContexts(MatchContexts value) const
238 {
239 d_ptr->mMatchContexts = value;
240 }
241
setSpecificity(unsigned int value) const242 void DefaultKeyFilter::setSpecificity(unsigned int value) const
243 {
244 d_ptr->mSpecificity = value;
245 }
246
setItalic(bool value) const247 void DefaultKeyFilter::setItalic(bool value) const
248 {
249 d_ptr->mItalic = value;
250 }
251
setBold(bool value) const252 void DefaultKeyFilter::setBold(bool value) const
253 {
254 d_ptr->mBold = value;
255 }
256
setStrikeOut(bool value) const257 void DefaultKeyFilter::setStrikeOut(bool value) const
258 {
259 d_ptr->mStrikeOut = value;
260 }
261
setUseFullFont(bool value) const262 void DefaultKeyFilter::setUseFullFont(bool value) const
263 {
264 d_ptr->mUseFullFont = value;
265 }
266
setFont(const QFont & value) const267 void DefaultKeyFilter::setFont(const QFont &value) const
268 {
269 d_ptr->mFont = value;
270 }
271
setRevoked(DefaultKeyFilter::TriState value) const272 void DefaultKeyFilter::setRevoked(DefaultKeyFilter::TriState value) const
273 {
274 d_ptr->mRevoked = value;
275 }
276
setExpired(DefaultKeyFilter::TriState value) const277 void DefaultKeyFilter::setExpired(DefaultKeyFilter::TriState value) const
278 {
279 d_ptr->mExpired = value;
280 }
281
setInvalid(DefaultKeyFilter::TriState value) const282 void DefaultKeyFilter::setInvalid(DefaultKeyFilter::TriState value) const
283 {
284 d_ptr->mInvalid = value;
285 }
286
setDisabled(DefaultKeyFilter::TriState value) const287 void DefaultKeyFilter::setDisabled(DefaultKeyFilter::TriState value) const
288 {
289 d_ptr->mDisabled = value;
290 }
291
setRoot(DefaultKeyFilter::TriState value) const292 void DefaultKeyFilter::setRoot(DefaultKeyFilter::TriState value) const
293 {
294 d_ptr->mRoot = value;
295 }
296
setCanEncrypt(DefaultKeyFilter::TriState value) const297 void DefaultKeyFilter::setCanEncrypt(DefaultKeyFilter::TriState value) const
298 {
299 d_ptr->mCanEncrypt = value;
300 }
301
setCanSign(DefaultKeyFilter::TriState value) const302 void DefaultKeyFilter::setCanSign(DefaultKeyFilter::TriState value) const
303 {
304 d_ptr->mCanSign = value;
305 }
306
setCanCertify(DefaultKeyFilter::TriState value) const307 void DefaultKeyFilter::setCanCertify(DefaultKeyFilter::TriState value) const
308 {
309 d_ptr->mCanCertify = value;
310 }
311
setCanAuthenticate(DefaultKeyFilter::TriState value) const312 void DefaultKeyFilter::setCanAuthenticate(DefaultKeyFilter::TriState value) const
313 {
314 d_ptr->mCanAuthenticate = value;
315 }
316
setQualified(DefaultKeyFilter::TriState value) const317 void DefaultKeyFilter::setQualified(DefaultKeyFilter::TriState value) const
318 {
319 d_ptr->mQualified = value;
320 }
321
setCardKey(DefaultKeyFilter::TriState value) const322 void DefaultKeyFilter::setCardKey(DefaultKeyFilter::TriState value) const
323 {
324 d_ptr->mCardKey = value;
325 }
326
setHasSecret(DefaultKeyFilter::TriState value) const327 void DefaultKeyFilter::setHasSecret(DefaultKeyFilter::TriState value) const
328 {
329 d_ptr->mHasSecret = value;
330 }
331
setIsOpenPGP(DefaultKeyFilter::TriState value) const332 void DefaultKeyFilter::setIsOpenPGP(DefaultKeyFilter::TriState value) const
333 {
334 d_ptr->mIsOpenPGP = value;
335 }
336
setWasValidated(DefaultKeyFilter::TriState value) const337 void DefaultKeyFilter::setWasValidated(DefaultKeyFilter::TriState value) const
338 {
339 d_ptr->mWasValidated = value;
340 }
341
setOwnerTrust(DefaultKeyFilter::LevelState value) const342 void DefaultKeyFilter::setOwnerTrust(DefaultKeyFilter::LevelState value) const
343 {
344 d_ptr->mOwnerTrust = value;
345 }
346
setOwnerTrustReferenceLevel(GpgME::Key::OwnerTrust value) const347 void DefaultKeyFilter::setOwnerTrustReferenceLevel(GpgME::Key::OwnerTrust value) const
348 {
349 d_ptr->mOwnerTrustReferenceLevel = value;
350 }
351
setValidity(DefaultKeyFilter::LevelState value) const352 void DefaultKeyFilter::setValidity(DefaultKeyFilter::LevelState value) const
353 {
354 d_ptr->mValidity = value;
355 }
356
setValidityReferenceLevel(GpgME::UserID::Validity value) const357 void DefaultKeyFilter::setValidityReferenceLevel(GpgME::UserID::Validity value) const
358 {
359 d_ptr->mValidityReferenceLevel = value;
360 }
361
setIsDeVs(DefaultKeyFilter::TriState value) const362 void DefaultKeyFilter::setIsDeVs(DefaultKeyFilter::TriState value) const
363 {
364 d_ptr->mIsDeVs = value;
365 }
366
setIsBad(DefaultKeyFilter::TriState value) const367 void DefaultKeyFilter::setIsBad(DefaultKeyFilter::TriState value) const
368 {
369 d_ptr->mBad = value;
370 }
371
fgColor() const372 QColor DefaultKeyFilter::fgColor() const
373 {
374 return d_ptr->mFgColor;
375 }
376
bgColor() const377 QColor DefaultKeyFilter::bgColor() const
378 {
379 return d_ptr->mBgColor;
380 }
381
name() const382 QString DefaultKeyFilter::name() const
383 {
384 return d_ptr->mName;
385 }
386
icon() const387 QString DefaultKeyFilter::icon() const
388 {
389 return d_ptr->mIcon;
390 }
391
id() const392 QString DefaultKeyFilter::id() const
393 {
394 return d_ptr->mId;
395 }
396
font() const397 QFont DefaultKeyFilter::font() const
398 {
399 return d_ptr->mFont;
400 }
401
availableMatchContexts() const402 KeyFilter::MatchContexts DefaultKeyFilter::availableMatchContexts() const
403 {
404 return d_ptr->mMatchContexts;
405 }
406
specificity() const407 unsigned int DefaultKeyFilter::specificity() const
408 {
409 return d_ptr->mSpecificity;
410 }
411
italic() const412 bool DefaultKeyFilter::italic() const
413 {
414 return d_ptr->mItalic;
415 }
416
bold() const417 bool DefaultKeyFilter::bold() const
418 {
419 return d_ptr->mBold;
420 }
421
strikeOut() const422 bool DefaultKeyFilter::strikeOut() const
423 {
424 return d_ptr->mStrikeOut;
425 }
426
useFullFont() const427 bool DefaultKeyFilter::useFullFont() const
428 {
429 return d_ptr->mUseFullFont;
430 }
431
revoked() const432 DefaultKeyFilter::TriState DefaultKeyFilter::revoked() const
433 {
434 return d_ptr->mRevoked;
435 }
436
expired() const437 DefaultKeyFilter::TriState DefaultKeyFilter::expired() const
438 {
439 return d_ptr->mExpired;
440 }
441
invalid() const442 DefaultKeyFilter::TriState DefaultKeyFilter::invalid() const
443 {
444 return d_ptr->mInvalid;
445 }
446
disabled() const447 DefaultKeyFilter::TriState DefaultKeyFilter::disabled() const
448 {
449 return d_ptr->mDisabled;
450 }
451
root() const452 DefaultKeyFilter::TriState DefaultKeyFilter::root() const
453 {
454 return d_ptr->mRoot;
455 }
456
canEncrypt() const457 DefaultKeyFilter::TriState DefaultKeyFilter::canEncrypt() const
458 {
459 return d_ptr->mCanEncrypt;
460 }
461
canSign() const462 DefaultKeyFilter::TriState DefaultKeyFilter::canSign() const
463 {
464 return d_ptr->mCanSign;
465 }
466
canCertify() const467 DefaultKeyFilter::TriState DefaultKeyFilter::canCertify() const
468 {
469 return d_ptr->mCanCertify;
470 }
471
canAuthenticate() const472 DefaultKeyFilter::TriState DefaultKeyFilter::canAuthenticate() const
473 {
474 return d_ptr->mCanAuthenticate;
475 }
476
qualified() const477 DefaultKeyFilter::TriState DefaultKeyFilter::qualified() const
478 {
479 return d_ptr->mQualified;
480 }
481
cardKey() const482 DefaultKeyFilter::TriState DefaultKeyFilter::cardKey() const
483 {
484 return d_ptr->mCardKey;
485 }
486
hasSecret() const487 DefaultKeyFilter::TriState DefaultKeyFilter::hasSecret() const
488 {
489 return d_ptr->mHasSecret;
490 }
491
isOpenPGP() const492 DefaultKeyFilter::TriState DefaultKeyFilter::isOpenPGP() const
493 {
494 return d_ptr->mIsOpenPGP;
495 }
496
wasValidated() const497 DefaultKeyFilter::TriState DefaultKeyFilter::wasValidated() const
498 {
499 return d_ptr->mWasValidated;
500 }
501
ownerTrust() const502 DefaultKeyFilter::LevelState DefaultKeyFilter::ownerTrust() const
503 {
504 return d_ptr->mOwnerTrust;
505 }
506
ownerTrustReferenceLevel() const507 GpgME::Key::OwnerTrust DefaultKeyFilter::ownerTrustReferenceLevel() const
508 {
509 return d_ptr->mOwnerTrustReferenceLevel;
510 }
511
validity() const512 DefaultKeyFilter::LevelState DefaultKeyFilter::validity() const
513 {
514 return d_ptr->mValidity;
515 }
516
validityReferenceLevel() const517 GpgME::UserID::Validity DefaultKeyFilter::validityReferenceLevel() const
518 {
519 return d_ptr->mValidityReferenceLevel;
520 }
521
isDeVS() const522 DefaultKeyFilter::TriState DefaultKeyFilter::isDeVS() const
523 {
524 return d_ptr->mIsDeVs;
525 }
526
isBad() const527 DefaultKeyFilter::TriState DefaultKeyFilter::isBad() const
528 {
529 return d_ptr->mBad;
530 }
531