Okular

signatureutils.cpp
1/*
2 SPDX-FileCopyrightText: 2018 Chinmoy Ranjan Pradhan <chinmoyrp65@gmail.com>
3
4 SPDX-License-Identifier: GPL-2.0-or-later
5*/
6
7#include "signatureutils.h"
8#include <KLocalizedString>
9
10using namespace Okular;
11
12static QString handleEmpty(const QString &string, CertificateInfo::EmptyString empty)
13{
14 if (string.isEmpty()) {
15 switch (empty) {
16 case CertificateInfo::EmptyString::Empty:
17 return {};
18 case CertificateInfo::EmptyString::TranslatedNotAvailable:
19 return i18n("Not Available");
20 }
21 return {};
22 }
23 return string;
24}
25
26class EntityInfo
27{
28public:
29 QString commonName;
30 QString distinguishedName;
31 QString emailAddress;
32 QString organization;
33};
34class Okular::CertificateInfoPrivate : public QSharedData
35{
36public:
37 bool isNull = true;
38 int version = -1;
39 QByteArray serialNumber;
40 EntityInfo issuerInfo;
41 EntityInfo subjectInfo;
42 QString nickName;
43 QDateTime validityStart;
44 QDateTime validityEnd;
45 CertificateInfo::KeyUsageExtensions keyUsageExtensions = CertificateInfo::KuNone;
46 QByteArray publicKey;
47 CertificateInfo::PublicKeyType publicKeyType = CertificateInfo::OtherKey;
48 int publicKeyStrength = -1;
49 bool isSelfSigned = false;
50 QByteArray certificateData;
51 CertificateInfo::Backend backend = CertificateInfo::Backend::Unknown;
52 CertificateInfo::KeyLocation keyLocation = CertificateInfo::KeyLocation::Unknown;
53 CertificateInfo::CertificateType certificateType = CertificateInfo::CertificateType::X509;
54 bool isQualified = false;
55 std::function<bool(QString)> checkPasswordFunction;
56};
57
58CertificateInfo::CertificateInfo()
59 : d {new CertificateInfoPrivate()}
60{
61}
62
63Okular::CertificateInfo::CertificateInfo(const Okular::CertificateInfo &other) = default;
64Okular::CertificateInfo::CertificateInfo(Okular::CertificateInfo &&other) noexcept = default;
65Okular::CertificateInfo &Okular::CertificateInfo::operator=(const Okular::CertificateInfo &other) = default;
66CertificateInfo &Okular::CertificateInfo::operator=(Okular::CertificateInfo &&other) noexcept = default;
67
68CertificateInfo::~CertificateInfo() = default;
69
70Q_DECLARE_OPERATORS_FOR_FLAGS(CertificateInfo::KeyUsageExtensions)
71
72bool CertificateInfo::isNull() const
73{
74 return d->isNull;
75}
76
77void CertificateInfo::setNull(bool isNull)
78{
79 d->isNull = isNull;
80}
81
82int CertificateInfo::version() const
83{
84 return d->version;
85}
86void CertificateInfo::setVersion(int version)
87{
88 d->version = version;
89}
90
91QByteArray CertificateInfo::serialNumber() const
92{
93 return d->serialNumber;
94}
95void CertificateInfo::setSerialNumber(const QByteArray &serialNumber)
96{
97 d->serialNumber = serialNumber;
98}
99
100QString CertificateInfo::issuerInfo(EntityInfoKey key, EmptyString empty) const
101{
102 switch (key) {
103 case EntityInfoKey::CommonName:
104 return handleEmpty(d->issuerInfo.commonName, empty);
105 case EntityInfoKey::DistinguishedName:
106 return handleEmpty(d->issuerInfo.distinguishedName, empty);
107 case EntityInfoKey::EmailAddress:
108 return handleEmpty(d->issuerInfo.emailAddress, empty);
109 case EntityInfoKey::Organization:
110 return handleEmpty(d->issuerInfo.organization, empty);
111 }
112 return QString();
113}
114
115void CertificateInfo::setIssuerInfo(EntityInfoKey key, const QString &value)
116{
117 switch (key) {
118 case EntityInfoKey::CommonName:
119 d->issuerInfo.commonName = value;
120 return;
121 case EntityInfoKey::DistinguishedName:
122 d->issuerInfo.distinguishedName = value;
123 return;
124 case EntityInfoKey::EmailAddress:
125 d->issuerInfo.emailAddress = value;
126 return;
127 case EntityInfoKey::Organization:
128 d->issuerInfo.organization = value;
129 return;
130 }
131}
132
133QString CertificateInfo::subjectInfo(EntityInfoKey key, EmptyString empty) const
134{
135 switch (key) {
136 case EntityInfoKey::CommonName:
137 return handleEmpty(d->subjectInfo.commonName, empty);
138 case EntityInfoKey::DistinguishedName:
139 return handleEmpty(d->subjectInfo.distinguishedName, empty);
140 case EntityInfoKey::EmailAddress:
141 return handleEmpty(d->subjectInfo.emailAddress, empty);
142 case EntityInfoKey::Organization:
143 return handleEmpty(d->subjectInfo.organization, empty);
144 }
145 return QString();
146}
147
148void CertificateInfo::setSubjectInfo(EntityInfoKey key, const QString &value)
149{
150 switch (key) {
151 case EntityInfoKey::CommonName:
152 d->subjectInfo.commonName = value;
153 return;
154 case EntityInfoKey::DistinguishedName:
155 d->subjectInfo.distinguishedName = value;
156 return;
157 case EntityInfoKey::EmailAddress:
158 d->subjectInfo.emailAddress = value;
159 return;
160 case EntityInfoKey::Organization:
161 d->subjectInfo.organization = value;
162 return;
163 }
164}
165
166QString CertificateInfo::nickName() const
167{
168 return d->nickName;
169}
170
171void CertificateInfo::setNickName(const QString &nickName)
172{
173 d->nickName = nickName;
174}
175
176QDateTime CertificateInfo::validityStart() const
177{
178 return d->validityStart;
179}
180
181void CertificateInfo::setValidityStart(const QDateTime &start)
182{
183 d->validityStart = start;
184}
185
186QDateTime CertificateInfo::validityEnd() const
187{
188 return d->validityEnd;
189}
190
191void Okular::CertificateInfo::setValidityEnd(const QDateTime &validityEnd)
192{
193 d->validityEnd = validityEnd;
194}
195
196CertificateInfo::KeyUsageExtensions CertificateInfo::keyUsageExtensions() const
197{
198 return d->keyUsageExtensions;
199}
200
201void Okular::CertificateInfo::setKeyUsageExtensions(Okular::CertificateInfo::KeyUsageExtensions ext)
202{
203 d->keyUsageExtensions = ext;
204}
205
206QByteArray CertificateInfo::publicKey() const
207{
208 return d->publicKey;
209}
210
211void Okular::CertificateInfo::setPublicKey(const QByteArray &publicKey)
212{
213 d->publicKey = publicKey;
214}
215
216CertificateInfo::PublicKeyType CertificateInfo::publicKeyType() const
217{
218 return d->publicKeyType;
219}
220
221void CertificateInfo::setPublicKeyType(PublicKeyType type)
222{
223 d->publicKeyType = type;
224}
225
226int CertificateInfo::publicKeyStrength() const
227{
228 return d->publicKeyStrength;
229}
230
231void CertificateInfo::setPublicKeyStrength(int strength)
232{
233 d->publicKeyStrength = strength;
234}
235
236bool CertificateInfo::isSelfSigned() const
237{
238 return d->isSelfSigned;
239}
240
241void CertificateInfo::setSelfSigned(bool selfSigned)
242{
243 d->isSelfSigned = selfSigned;
244}
245
246QByteArray CertificateInfo::certificateData() const
247{
248 return d->certificateData;
249}
250
251void CertificateInfo::setCertificateData(const QByteArray &certificateData)
252{
253 d->certificateData = certificateData;
254}
255
256CertificateInfo::KeyLocation CertificateInfo::keyLocation() const
257{
258 return d->keyLocation;
259}
260
261void CertificateInfo::setKeyLocation(KeyLocation location)
262{
263 d->keyLocation = location;
264}
265
266CertificateInfo::Backend CertificateInfo::backend() const
267{
268 return d->backend;
269}
270
271void CertificateInfo::setBackend(Backend backend)
272{
273 d->backend = backend;
274}
275
276bool CertificateInfo::checkPassword(const QString &password) const
277{
278 if (d->checkPasswordFunction) {
279 return d->checkPasswordFunction(password);
280 }
281 return false;
282}
283
284void CertificateInfo::setCheckPasswordFunction(const std::function<bool(const QString &)> &passwordFunction)
285{
286 d->checkPasswordFunction = passwordFunction;
287}
288
289bool CertificateInfo::isQualified() const
290{
291 return d->isQualified;
292}
293
294void CertificateInfo::setQualified(bool qualified)
295{
296 d->isQualified = qualified;
297}
298
299CertificateInfo::CertificateType CertificateInfo::certificateType() const
300{
301 return d->certificateType;
302}
303
304void CertificateInfo::setCertificateType(CertificateType type)
305{
306 d->certificateType = type;
307}
308
309class Okular::SignatureInfoPrivate : public QSharedData
310{
311public:
312 SignatureInfo::SignatureStatus signatureStatus = SignatureInfo::SignatureStatusUnknown;
313 SignatureInfo::CertificateStatus certificateStatus = SignatureInfo::CertificateStatusUnknown;
314 SignatureInfo::HashAlgorithm hashAlgorithm = SignatureInfo::HashAlgorithmUnknown;
315 QString signerName;
316 QString signerSubjectDN;
317 QString location;
318 QString reason;
319 QDateTime signingTime;
320 QByteArray signature;
321 QList<qint64> signedRangeBounds;
322 bool signsTotalDocument = false;
323 CertificateInfo certificateInfo;
324};
325
326SignatureInfo::SignatureInfo()
327 : d {new SignatureInfoPrivate()}
328{
329}
330
331SignatureInfo::SignatureInfo(SignatureInfo &&other) noexcept = default;
332SignatureInfo::SignatureInfo(const SignatureInfo &other) = default;
333SignatureInfo &SignatureInfo::operator=(SignatureInfo &&other) noexcept = default;
334Okular::SignatureInfo &Okular::SignatureInfo::operator=(const Okular::SignatureInfo &other) = default;
335SignatureInfo::~SignatureInfo() = default;
336
337SignatureInfo::SignatureStatus SignatureInfo::signatureStatus() const
338{
339 return d->signatureStatus;
340}
341
342void SignatureInfo::setSignatureStatus(SignatureInfo::SignatureStatus status)
343{
344 d->signatureStatus = status;
345}
346
347SignatureInfo::CertificateStatus SignatureInfo::certificateStatus() const
348{
349 return d->certificateStatus;
350}
351
352void SignatureInfo::setCertificateStatus(SignatureInfo::CertificateStatus status)
353{
354 d->certificateStatus = status;
355}
356
357SignatureInfo::HashAlgorithm SignatureInfo::hashAlgorithm() const
358{
359 return d->hashAlgorithm;
360}
361
362void Okular::SignatureInfo::setHashAlgorithm(Okular::SignatureInfo::HashAlgorithm algorithm)
363{
364 d->hashAlgorithm = algorithm;
365}
366
367QString SignatureInfo::signerName() const
368{
369 return d->signerName;
370}
371
372void SignatureInfo::setSignerName(const QString &signerName)
373{
374 d->signerName = signerName;
375}
376
377QString SignatureInfo::signerSubjectDN() const
378{
379 return d->signerSubjectDN;
380}
381
382void Okular::SignatureInfo::setSignerSubjectDN(const QString &signerSubjectDN)
383{
384 d->signerSubjectDN = signerSubjectDN;
385}
386
387QString SignatureInfo::location() const
388{
389 return d->location;
390}
391
392void SignatureInfo::setLocation(const QString &location)
393{
394 d->location = location;
395}
396
397QString SignatureInfo::reason() const
398{
399 return d->reason;
400}
401
402void Okular::SignatureInfo::setReason(const QString &reason)
403{
404 d->reason = reason;
405}
406
407QDateTime SignatureInfo::signingTime() const
408{
409 return d->signingTime;
410}
411
412void Okular::SignatureInfo::setSigningTime(const QDateTime &time)
413{
414 d->signingTime = time;
415}
416
417QByteArray SignatureInfo::signature() const
418{
419 return d->signature;
420}
421
422void SignatureInfo::setSignature(const QByteArray &signature)
423{
424 d->signature = signature;
425}
426
427QList<qint64> SignatureInfo::signedRangeBounds() const
428{
429 return d->signedRangeBounds;
430}
431
432void SignatureInfo::setSignedRangeBounds(const QList<qint64> &range)
433{
434 d->signedRangeBounds = range;
435}
436
437bool SignatureInfo::signsTotalDocument() const
438{
439 return d->signsTotalDocument;
440}
441
442void SignatureInfo::setSignsTotalDocument(bool total)
443{
444 d->signsTotalDocument = total;
445}
446
447CertificateInfo SignatureInfo::certificateInfo() const
448{
449 return d->certificateInfo;
450}
451
452void SignatureInfo::setCertificateInfo(const Okular::CertificateInfo &info)
453{
454 d->certificateInfo = info;
455}
456
457CertificateStore::CertificateStore()
458{
459}
460
464
465QList<CertificateInfo> CertificateStore::signingCertificates(bool *userCancelled) const
466{
467 *userCancelled = false;
468 return QList<CertificateInfo>();
469}
470
471QList<CertificateInfo> CertificateStore::signingCertificatesForNow(bool *userCancelled, bool *nonDateValidCerts) const
472{
473 const QDateTime now = QDateTime::currentDateTime();
474 QList<Okular::CertificateInfo> certs = signingCertificates(userCancelled);
475 auto it = certs.begin();
476 *nonDateValidCerts = false;
477 while (it != certs.end()) {
478 if (it->validityStart() > now || (it->validityEnd().isValid() && now > it->validityEnd())) {
479 it = certs.erase(it);
480 *nonDateValidCerts = true;
481 } else {
482 ++it;
483 }
484 }
485 return certs;
486}
Okular::CertificateStore::signingCertificatesForNow
QList< CertificateInfo > signingCertificatesForNow(bool *userCancelled, bool *nonDateValidCerts) const
Returns list of valid, usable signing certificates for current date and time.
Definition signatureutils.cpp:471
Okular::CertificateStore::~CertificateStore
virtual ~CertificateStore()
Destructor.
Definition signatureutils.cpp:461
Okular::CertificateStore::signingCertificates
virtual QList< CertificateInfo > signingCertificates(bool *userCancelled) const
Returns list of valid, usable signing certificates.
Definition signatureutils.cpp:465
status
Q_SCRIPTABLE CaptureState status()
start
Q_SCRIPTABLE Q_NOREPLY void start()
i18n
QString i18n(const char *text, const TYPE &arg...)
Akonadi::Server::DbType::type
Type type(const QSqlDatabase &db)
KItinerary::LocationUtil::location
QVariant location(const QVariant &res)
Okular
global.h
Definition action.h:17
QCA::CertificateInfo
QMultiMap< CertificateInfoType, QString > CertificateInfo
QDateTime::currentDateTime
QDateTime currentDateTime()
QList::begin
iterator begin()
QList::end
iterator end()
QList::erase
iterator erase(const_iterator begin, const_iterator end)
This file is part of the KDE documentation.
Documentation copyright © 1996-2025 The KDE developers.
Generated on Fri Mar 7 2025 11:54:37 by doxygen 1.13.2 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.