Okular

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

KDE's Doxygen guidelines are available online.