Debian Codegraph @

qt5/src/poppler-form.cc

raw
1 /* poppler-form.h: qt interface to poppler
2 * Copyright (C) 2007-2008, 2011, Pino Toscano <[email protected]>
3 * Copyright (C) 2008, 2011, 2012, 2015-2025 Albert Astals Cid <[email protected]>
4 * Copyright (C) 2011 Carlos Garcia Campos <[email protected]>
5 * Copyright (C) 2012, Adam Reichold <[email protected]>
6 * Copyright (C) 2016, Hanno Meyer-Thurow <[email protected]>
7 * Copyright (C) 2017, Hans-Ulrich Jüttner <[email protected]>
8 * Copyright (C) 2018, Andre Heinecke <[email protected]>
9 * Copyright (C) 2018 Klarälvdalens Datakonsult AB, a KDAB Group company, <[email protected]>. Work sponsored by the LiMux project of the city of Munich
10 * Copyright (C) 2018 Chinmoy Ranjan Pradhan <[email protected]>
11 * Copyright (C) 2018, 2020 Oliver Sander <[email protected]>
12 * Copyright (C) 2019 João Netto <[email protected]>
13 * Copyright (C) 2020 David García Garzón <[email protected]>
14 * Copyright (C) 2020 Thorsten Behrens <[email protected]>
15 * Copyright (C) 2020 Klarälvdalens Datakonsult AB, a KDAB Group company, <[email protected]>. Work sponsored by Technische Universität Dresden
16 * Copyright (C) 2021 Georgiy Sgibnev <[email protected]>. Work sponsored by lab50.net.
17 * Copyright (C) 2021 Theofilos Intzoglou <[email protected]>
18 * Copyright (C) 2022 Alexander Sulfrian <[email protected]>
19 * Copyright (C) 2023-2025 g10 Code GmbH, Author: Sune Stolborg Vuorela <[email protected]>
20 * Copyright (C) 2024 Pratham Gandhi <[email protected]>
21 * Copyright (C) 2024 Stefan Brüns <[email protected]>
22 * Copyright (C) 2025 Blair Bonnett <[email protected]>
23 *
24 * This program is free software; you can redistribute it and/or modify
25 * it under the terms of the GNU General Public License as published by
26 * the Free Software Foundation; either version 2, or (at your option)
27 * any later version.
28 *
29 * This program is distributed in the hope that it will be useful,
30 * but WITHOUT ANY WARRANTY; without even the implied warranty of
31 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
32 * GNU General Public License for more details.
33 *
34 * You should have received a copy of the GNU General Public License
35 * along with this program; if not, write to the Free Software
36 * Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
37 */
38
39 #include "poppler-form.h"
40
41 #include <config.h>
42
43 #include <QtCore/QSizeF>
44 #include <QTimeZone>
45 #include <QUrl>
46
47 #include <Form.h>
48 #include <Object.h>
49 #include <Link.h>
50 #include <SignatureInfo.h>
51 #include <CertificateInfo.h>
52 #include <CryptoSignBackend.h>
53 #if ENABLE_NSS3
54 # include <NSSCryptoSignBackend.h>
55 #endif
56 #if ENABLE_GPGME
57 # include <GPGMECryptoSignBackendConfiguration.h>
58 #endif
59
60 #include "poppler-page-private.h"
61 #include "poppler-private.h"
62 #include "poppler-annotation-helper.h"
63
64 namespace {
65
66 Qt::Alignment formTextAlignment(::FormWidget *fm)
67 {
68 Qt::Alignment qtalign = Qt::AlignLeft;
69 switch (fm->getField()->getTextQuadding()) {
70 case VariableTextQuadding::centered:
71 qtalign = Qt::AlignHCenter;
72 break;
73 case VariableTextQuadding::rightJustified:
74 qtalign = Qt::AlignRight;
75 break;
76 case VariableTextQuadding::leftJustified:
77 qtalign = Qt::AlignLeft;
78 }
79 return qtalign;
80 }
81
82 }
83
84 namespace Poppler {
85
86 FormFieldIcon::FormFieldIcon(FormFieldIconData *data) : d_ptr(data) { }
87
88 FormFieldIcon::FormFieldIcon(const FormFieldIcon &ffIcon)
89 {
90 d_ptr = new FormFieldIconData;
91 d_ptr->icon = ffIcon.d_ptr->icon;
92 }
93
94 FormFieldIcon &FormFieldIcon::operator=(const FormFieldIcon &ffIcon)
95 {
96 if (this != &ffIcon) {
97 delete d_ptr;
98 d_ptr = nullptr;
99
100 d_ptr = new FormFieldIconData;
101 *d_ptr = *ffIcon.d_ptr;
102 }
103
104 return *this;
105 }
106
107 FormFieldIcon::~FormFieldIcon()
108 {
109 delete d_ptr;
110 }
111
112 FormField::FormField(std::unique_ptr<FormFieldData> dd) : m_formData(std::move(dd))
113 {
114 if (m_formData->page) {
115 const int rotation = m_formData->page->getRotate();
116 // reading the coords
117 double left, top, right, bottom;
118 m_formData->fm->getRect(&left, &bottom, &right, &top);
119 // build a normalized transform matrix for this page at 100% scale
120 GfxState gfxState(72.0, 72.0, m_formData->page->getCropBox(), rotation, true);
121 const double *gfxCTM = gfxState.getCTM();
122 double MTX[6];
123 double pageWidth = m_formData->page->getCropWidth();
124 double pageHeight = m_formData->page->getCropHeight();
125 // landscape and seascape page rotation: be sure to use the correct (== rotated) page size
126 if (((rotation / 90) % 2) == 1) {
127 qSwap(pageWidth, pageHeight);
128 }
129 for (int i = 0; i < 6; i += 2) {
130 MTX[i] = gfxCTM[i] / pageWidth;
131 MTX[i + 1] = gfxCTM[i + 1] / pageHeight;
132 }
133 QPointF topLeft;
134 XPDFReader::transform(MTX, qMin(left, right), qMax(top, bottom), topLeft);
135 QPointF bottomRight;
136 XPDFReader::transform(MTX, qMax(left, right), qMin(top, bottom), bottomRight);
137 m_formData->box = QRectF(topLeft, QSizeF(bottomRight.x() - topLeft.x(), bottomRight.y() - topLeft.y()));
138 }
139 }
140
141 FormField::~FormField() = default;
142
143 QRectF FormField::rect() const
144 {
145 return m_formData->box;
146 }
147
148 int FormField::id() const
149 {
150 return m_formData->fm->getID();
151 }
152
153 QString FormField::name() const
154 {
155 QString name;
156 if (const GooString *goo = m_formData->fm->getPartialName()) {
157 name = UnicodeParsedString(goo);
158 }
159 return name;
160 }
161
162 void FormField::setName(const QString &name) const
163 {
164 const std::unique_ptr<GooString> goo = QStringToGooString(name);
165 m_formData->fm->setPartialName(*goo);
166 }
167
168 QString FormField::fullyQualifiedName() const
169 {
170 QString name;
171 if (const GooString *goo = m_formData->fm->getFullyQualifiedName()) {
172 name = UnicodeParsedString(goo);
173 }
174 return name;
175 }
176
177 QString FormField::uiName() const
178 {
179 QString name;
180 if (const GooString *goo = m_formData->fm->getAlternateUiName()) {
181 name = UnicodeParsedString(goo);
182 }
183 return name;
184 }
185
186 bool FormField::isReadOnly() const
187 {
188 return m_formData->fm->isReadOnly();
189 }
190
191 void FormField::setReadOnly(bool value)
192 {
193 m_formData->fm->setReadOnly(value);
194 }
195
196 bool FormField::isVisible() const
197 {
198 const unsigned int flags = m_formData->fm->getWidgetAnnotation()->getFlags();
199 if (flags & Annot::flagHidden) {
200 return false;
201 }
202 if (flags & Annot::flagNoView) {
203 return false;
204 }
205 return true;
206 }
207
208 void FormField::setVisible(bool value)
209 {
210 unsigned int flags = m_formData->fm->getWidgetAnnotation()->getFlags();
211 if (value) {
212 flags &= ~Annot::flagHidden;
213 flags &= ~Annot::flagNoView;
214 } else {
215 flags |= Annot::flagHidden;
216 }
217 m_formData->fm->getWidgetAnnotation()->setFlags(flags);
218 }
219
220 bool FormField::isPrintable() const
221 {
222 return (m_formData->fm->getWidgetAnnotation()->getFlags() & Annot::flagPrint);
223 }
224
225 void FormField::setPrintable(bool value)
226 {
227 unsigned int flags = m_formData->fm->getWidgetAnnotation()->getFlags();
228 if (value) {
229 flags |= Annot::flagPrint;
230 } else {
231 flags &= ~Annot::flagPrint;
232 }
233 m_formData->fm->getWidgetAnnotation()->setFlags(flags);
234 }
235
236 Link *FormField::activationAction() const
237 {
238 Link *action = nullptr;
239 if (::LinkAction *act = m_formData->fm->getActivationAction()) {
240 action = PageData::convertLinkActionToLink(act, m_formData->doc, QRectF());
241 }
242 return action;
243 }
244
245 Link *FormField::additionalAction(AdditionalActionType type) const
246 {
247 Annot::FormAdditionalActionsType actionType = Annot::actionFieldModified;
248 switch (type) {
249 case FieldModified:
250 actionType = Annot::actionFieldModified;
251 break;
252 case FormatField:
253 actionType = Annot::actionFormatField;
254 break;
255 case ValidateField:
256 actionType = Annot::actionValidateField;
257 break;
258 case CalculateField:
259 actionType = Annot::actionCalculateField;
260 break;
261 }
262
263 Link *action = nullptr;
264 if (std::unique_ptr<::LinkAction> act = m_formData->fm->getAdditionalAction(actionType)) {
265 action = PageData::convertLinkActionToLink(act.get(), m_formData->doc, QRectF());
266 }
267 return action;
268 }
269
270 Link *FormField::additionalAction(Annotation::AdditionalActionType type) const
271 {
272 std::shared_ptr<AnnotWidget> w = m_formData->fm->getWidgetAnnotation();
273 if (!w) {
274 return nullptr;
275 }
276
277 const Annot::AdditionalActionsType actionType = toPopplerAdditionalActionType(type);
278
279 Link *action = nullptr;
280 if (std::unique_ptr<::LinkAction> act = w->getAdditionalAction(actionType)) {
281 action = PageData::convertLinkActionToLink(act.get(), m_formData->doc, QRectF());
282 }
283 return action;
284 }
285
286 FormFieldButton::FormFieldButton(DocumentData *doc, ::Page *p, ::FormWidgetButton *w) : FormField(std::make_unique<FormFieldData>(doc, p, w)) { }
287
288 FormFieldButton::~FormFieldButton() = default;
289
290 FormFieldButton::FormType FormFieldButton::type() const
291 {
292 return FormField::FormButton;
293 }
294
295 FormFieldButton::ButtonType FormFieldButton::buttonType() const
296 {
297 FormWidgetButton *fwb = static_cast<FormWidgetButton *>(m_formData->fm);
298 switch (fwb->getButtonType()) {
299 case formButtonCheck:
300 return FormFieldButton::CheckBox;
301 break;
302 case formButtonPush:
303 return FormFieldButton::Push;
304 break;
305 case formButtonRadio:
306 return FormFieldButton::Radio;
307 break;
308 }
309 return FormFieldButton::CheckBox;
310 }
311
312 QString FormFieldButton::caption() const
313 {
314 FormWidgetButton *fwb = static_cast<FormWidgetButton *>(m_formData->fm);
315 QString ret;
316 if (fwb->getButtonType() == formButtonPush) {
317 Dict *dict = m_formData->fm->getObj()->getDict();
318 Object obj1 = dict->lookup("MK");
319 if (obj1.isDict()) {
320 AnnotAppearanceCharacs appearCharacs(obj1.getDict());
321 if (appearCharacs.getNormalCaption()) {
322 ret = UnicodeParsedString(appearCharacs.getNormalCaption());
323 }
324 }
325 } else {
326 if (const char *goo = fwb->getOnStr()) {
327 ret = QString::fromUtf8(goo);
328 }
329 }
330 return ret;
331 }
332
333 FormFieldIcon FormFieldButton::icon() const
334 {
335 FormWidgetButton *fwb = static_cast<FormWidgetButton *>(m_formData->fm);
336 if (fwb->getButtonType() == formButtonPush) {
337 Dict *dict = m_formData->fm->getObj()->getDict();
338 FormFieldIconData *data = new FormFieldIconData;
339 data->icon = dict;
340 return FormFieldIcon(data);
341 }
342 return FormFieldIcon(nullptr);
343 }
344
345 void FormFieldButton::setIcon(const FormFieldIcon &icon)
346 {
347 if (FormFieldIconData::getData(icon) == nullptr) {
348 return;
349 }
350
351 FormWidgetButton *fwb = static_cast<FormWidgetButton *>(m_formData->fm);
352 if (fwb->getButtonType() == formButtonPush) {
353 ::AnnotWidget *w = m_formData->fm->getWidgetAnnotation().get();
354 FormFieldIconData *data = FormFieldIconData::getData(icon);
355 if (data->icon != nullptr) {
356 w->setNewAppearance(data->icon->lookup("AP"));
357 }
358 }
359 }
360
361 bool FormFieldButton::state() const
362 {
363 FormWidgetButton *fwb = static_cast<FormWidgetButton *>(m_formData->fm);
364 return fwb->getState();
365 }
366
367 void FormFieldButton::setState(bool state)
368 {
369 FormWidgetButton *fwb = static_cast<FormWidgetButton *>(m_formData->fm);
370 fwb->setState((bool)state);
371 }
372
373 QList<int> FormFieldButton::siblings() const
374 {
375 FormWidgetButton *fwb = static_cast<FormWidgetButton *>(m_formData->fm);
376 ::FormFieldButton *ffb = static_cast<::FormFieldButton *>(fwb->getField());
377 if (fwb->getButtonType() == formButtonPush) {
378 return QList<int>();
379 }
380
381 QList<int> ret;
382 for (int i = 0; i < ffb->getNumSiblings(); ++i) {
383 ::FormFieldButton *sibling = static_cast<::FormFieldButton *>(ffb->getSibling(i));
384 for (int j = 0; j < sibling->getNumWidgets(); ++j) {
385 FormWidget *w = sibling->getWidget(j);
386 if (w) {
387 ret.append(w->getID());
388 }
389 }
390 }
391
392 return ret;
393 }
394
395 FormFieldText::FormFieldText(DocumentData *doc, ::Page *p, ::FormWidgetText *w) : FormField(std::make_unique<FormFieldData>(doc, p, w)) { }
396
397 FormFieldText::~FormFieldText() = default;
398
399 FormField::FormType FormFieldText::type() const
400 {
401 return FormField::FormText;
402 }
403
404 FormFieldText::TextType FormFieldText::textType() const
405 {
406 FormWidgetText *fwt = static_cast<FormWidgetText *>(m_formData->fm);
407 if (fwt->isFileSelect()) {
408 return FormFieldText::FileSelect;
409 } else if (fwt->isMultiline()) {
410 return FormFieldText::Multiline;
411 }
412 return FormFieldText::Normal;
413 }
414
415 QString FormFieldText::text() const
416 {
417 const GooString *goo = static_cast<FormWidgetText *>(m_formData->fm)->getContent();
418 return UnicodeParsedString(goo);
419 }
420
421 void FormFieldText::setText(const QString &text)
422 {
423 FormWidgetText *fwt = static_cast<FormWidgetText *>(m_formData->fm);
424 std::unique_ptr<GooString> goo = QStringToUnicodeGooString(text);
425 fwt->setContent(std::move(goo));
426 }
427
428 void FormFieldText::setAppearanceText(const QString &text)
429 {
430 FormWidgetText *fwt = static_cast<FormWidgetText *>(m_formData->fm);
431 std::unique_ptr<GooString> goo = QStringToUnicodeGooString(text);
432 fwt->setAppearanceContent(std::move(goo));
433 }
434
435 bool FormFieldText::isPassword() const
436 {
437 FormWidgetText *fwt = static_cast<FormWidgetText *>(m_formData->fm);
438 return fwt->isPassword();
439 }
440
441 bool FormFieldText::isRichText() const
442 {
443 FormWidgetText *fwt = static_cast<FormWidgetText *>(m_formData->fm);
444 return fwt->isRichText();
445 }
446
447 int FormFieldText::maximumLength() const
448 {
449 FormWidgetText *fwt = static_cast<FormWidgetText *>(m_formData->fm);
450 const int maxlen = fwt->getMaxLen();
451 return maxlen > 0 ? maxlen : -1;
452 }
453
454 Qt::Alignment FormFieldText::textAlignment() const
455 {
456 return formTextAlignment(m_formData->fm);
457 }
458
459 bool FormFieldText::canBeSpellChecked() const
460 {
461 FormWidgetText *fwt = static_cast<FormWidgetText *>(m_formData->fm);
462 return !fwt->noSpellCheck();
463 }
464
465 double FormFieldText::getFontSize() const
466 {
467 FormWidgetText *fwt = static_cast<FormWidgetText *>(m_formData->fm);
468 return fwt->getTextFontSize();
469 }
470
471 void FormFieldText::setFontSize(int fontSize)
472 {
473 FormWidgetText *fwt = static_cast<FormWidgetText *>(m_formData->fm);
474 fwt->setTextFontSize(fontSize);
475 }
476
477 FormFieldChoice::FormFieldChoice(DocumentData *doc, ::Page *p, ::FormWidgetChoice *w) : FormField(std::make_unique<FormFieldData>(doc, p, w)) { }
478
479 FormFieldChoice::~FormFieldChoice() = default;
480
481 FormFieldChoice::FormType FormFieldChoice::type() const
482 {
483 return FormField::FormChoice;
484 }
485
486 FormFieldChoice::ChoiceType FormFieldChoice::choiceType() const
487 {
488 FormWidgetChoice *fwc = static_cast<FormWidgetChoice *>(m_formData->fm);
489 if (fwc->isCombo()) {
490 return FormFieldChoice::ComboBox;
491 }
492 return FormFieldChoice::ListBox;
493 }
494
495 QStringList FormFieldChoice::choices() const
496 {
497 FormWidgetChoice *fwc = static_cast<FormWidgetChoice *>(m_formData->fm);
498 QStringList ret;
499 int num = fwc->getNumChoices();
500 ret.reserve(num);
501 for (int i = 0; i < num; ++i) {
502 ret.append(UnicodeParsedString(fwc->getChoice(i)));
503 }
504 return ret;
505 }
506
507 QVector<QPair<QString, QString>> FormFieldChoice::choicesWithExportValues() const
508 {
509 FormWidgetChoice *fwc = static_cast<FormWidgetChoice *>(m_formData->fm);
510 QVector<QPair<QString, QString>> ret;
511 const int num = fwc->getNumChoices();
512 ret.reserve(num);
513 for (int i = 0; i < num; ++i) {
514 const QString display = UnicodeParsedString(fwc->getChoice(i));
515 const GooString *exportValueG = fwc->getExportVal(i);
516 const QString exportValue = exportValueG ? UnicodeParsedString(exportValueG) : display;
517 ret.append({ display, exportValue });
518 }
519 return ret;
520 }
521
522 bool FormFieldChoice::isEditable() const
523 {
524 FormWidgetChoice *fwc = static_cast<FormWidgetChoice *>(m_formData->fm);
525 return fwc->isCombo() ? fwc->hasEdit() : false;
526 }
527
528 bool FormFieldChoice::multiSelect() const
529 {
530 FormWidgetChoice *fwc = static_cast<FormWidgetChoice *>(m_formData->fm);
531 return !fwc->isCombo() ? fwc->isMultiSelect() : false;
532 }
533
534 QList<int> FormFieldChoice::currentChoices() const
535 {
536 FormWidgetChoice *fwc = static_cast<FormWidgetChoice *>(m_formData->fm);
537 int num = fwc->getNumChoices();
538 QList<int> choices;
539 for (int i = 0; i < num; ++i) {
540 if (fwc->isSelected(i)) {
541 choices.append(i);
542 }
543 }
544 return choices;
545 }
546
547 void FormFieldChoice::setCurrentChoices(const QList<int> &choice)
548 {
549 FormWidgetChoice *fwc = static_cast<FormWidgetChoice *>(m_formData->fm);
550 fwc->deselectAll();
551 for (int i = 0; i < choice.count(); ++i) {
552 fwc->select(choice.at(i));
553 }
554 }
555
556 QString FormFieldChoice::editChoice() const
557 {
558 FormWidgetChoice *fwc = static_cast<FormWidgetChoice *>(m_formData->fm);
559
560 if (fwc->isCombo() && fwc->hasEdit()) {
561 return UnicodeParsedString(fwc->getEditChoice());
562 } else {
563 return QString();
564 }
565 }
566
567 void FormFieldChoice::setEditChoice(const QString &text)
568 {
569 FormWidgetChoice *fwc = static_cast<FormWidgetChoice *>(m_formData->fm);
570
571 if (fwc->isCombo() && fwc->hasEdit()) {
572 std::unique_ptr<GooString> goo = QStringToUnicodeGooString(text);
573 fwc->setEditChoice(std::move(goo));
574 }
575 }
576
577 Qt::Alignment FormFieldChoice::textAlignment() const
578 {
579 return formTextAlignment(m_formData->fm);
580 }
581
582 bool FormFieldChoice::canBeSpellChecked() const
583 {
584 FormWidgetChoice *fwc = static_cast<FormWidgetChoice *>(m_formData->fm);
585 return !fwc->noSpellCheck();
586 }
587
588 void FormFieldChoice::setAppearanceChoiceText(const QString &text)
589 {
590 FormWidgetChoice *fwc = static_cast<FormWidgetChoice *>(m_formData->fm);
591 std::unique_ptr<GooString> goo = QStringToUnicodeGooString(text);
592 fwc->setAppearanceChoiceContent(std::move(goo));
593 }
594
595 class CertificateInfoPrivate
596 {
597 public:
598 struct EntityInfo
599 {
600 QString common_name;
601 QString email_address;
602 QString org_name;
603 QString distinguished_name;
604 };
605
606 EntityInfo issuer_info;
607 EntityInfo subject_info;
608 QString nick_name;
609 QByteArray certificate_der;
610 QByteArray serial_number;
611 QByteArray public_key;
612 QDateTime validity_start;
613 QDateTime validity_end;
614 int public_key_type;
615 int public_key_strength;
616 int ku_extensions;
617 int version;
618 bool is_self_signed;
619 bool is_null;
620 CertificateInfo::KeyLocation keyLocation;
621 CertificateInfo::CertificateType certificateType;
622 };
623
624 CertificateInfo::CertificateInfo() : d_ptr(new CertificateInfoPrivate())
625 {
626 d_ptr->is_null = true;
627 }
628
629 CertificateInfo::CertificateInfo(CertificateInfoPrivate *priv) : d_ptr(priv) { }
630
631 CertificateInfo::CertificateInfo(const CertificateInfo &other) = default;
632
633 CertificateInfo::~CertificateInfo() = default;
634
635 CertificateInfo &CertificateInfo::operator=(const CertificateInfo &other)
636 {
637 if (this != &other) {
638 d_ptr = other.d_ptr;
639 }
640
641 return *this;
642 }
643
644 bool CertificateInfo::isNull() const
645 {
646 Q_D(const CertificateInfo);
647 return d->is_null;
648 }
649
650 int CertificateInfo::version() const
651 {
652 Q_D(const CertificateInfo);
653 return d->version;
654 }
655
656 QByteArray CertificateInfo::serialNumber() const
657 {
658 Q_D(const CertificateInfo);
659 return d->serial_number;
660 }
661
662 CertificateInfo::CertificateType CertificateInfo::certificateType() const
663 {
664 Q_D(const CertificateInfo);
665 return d->certificateType;
666 }
667
668 QString CertificateInfo::issuerInfo(EntityInfoKey key) const
669 {
670 Q_D(const CertificateInfo);
671 switch (key) {
672 case CommonName:
673 return d->issuer_info.common_name;
674 case DistinguishedName:
675 return d->issuer_info.distinguished_name;
676 case EmailAddress:
677 return d->issuer_info.email_address;
678 case Organization:
679 return d->issuer_info.org_name;
680 default:
681 return QString();
682 }
683 }
684
685 QString CertificateInfo::subjectInfo(EntityInfoKey key) const
686 {
687 Q_D(const CertificateInfo);
688 switch (key) {
689 case CommonName:
690 return d->subject_info.common_name;
691 case DistinguishedName:
692 return d->subject_info.distinguished_name;
693 case EmailAddress:
694 return d->subject_info.email_address;
695 case Organization:
696 return d->subject_info.org_name;
697 default:
698 return QString();
699 }
700 }
701
702 QString CertificateInfo::nickName() const
703 {
704 Q_D(const CertificateInfo);
705 return d->nick_name;
706 }
707
708 QDateTime CertificateInfo::validityStart() const
709 {
710 Q_D(const CertificateInfo);
711 return d->validity_start;
712 }
713
714 QDateTime CertificateInfo::validityEnd() const
715 {
716 Q_D(const CertificateInfo);
717 return d->validity_end;
718 }
719
720 CertificateInfo::KeyUsageExtensions CertificateInfo::keyUsageExtensions() const
721 {
722 Q_D(const CertificateInfo);
723
724 KeyUsageExtensions kuExtensions = KuNone;
725 if (d->ku_extensions & KU_DIGITAL_SIGNATURE) {
726 kuExtensions |= KuDigitalSignature;
727 }
728 if (d->ku_extensions & KU_NON_REPUDIATION) {
729 kuExtensions |= KuNonRepudiation;
730 }
731 if (d->ku_extensions & KU_KEY_ENCIPHERMENT) {
732 kuExtensions |= KuKeyEncipherment;
733 }
734 if (d->ku_extensions & KU_DATA_ENCIPHERMENT) {
735 kuExtensions |= KuDataEncipherment;
736 }
737 if (d->ku_extensions & KU_KEY_AGREEMENT) {
738 kuExtensions |= KuKeyAgreement;
739 }
740 if (d->ku_extensions & KU_KEY_CERT_SIGN) {
741 kuExtensions |= KuKeyCertSign;
742 }
743 if (d->ku_extensions & KU_CRL_SIGN) {
744 kuExtensions |= KuClrSign;
745 }
746 if (d->ku_extensions & KU_ENCIPHER_ONLY) {
747 kuExtensions |= KuEncipherOnly;
748 }
749
750 return kuExtensions;
751 }
752
753 CertificateInfo::KeyLocation CertificateInfo::keyLocation() const
754 {
755 Q_D(const CertificateInfo);
756 return d->keyLocation;
757 }
758
759 QByteArray CertificateInfo::publicKey() const
760 {
761 Q_D(const CertificateInfo);
762 return d->public_key;
763 }
764
765 CertificateInfo::PublicKeyType CertificateInfo::publicKeyType() const
766 {
767 Q_D(const CertificateInfo);
768 switch (d->public_key_type) {
769 case RSAKEY:
770 return RsaKey;
771 case DSAKEY:
772 return DsaKey;
773 case ECKEY:
774 return EcKey;
775 default:
776 return OtherKey;
777 }
778 }
779
780 int CertificateInfo::publicKeyStrength() const
781 {
782 Q_D(const CertificateInfo);
783 return d->public_key_strength;
784 }
785
786 bool CertificateInfo::isSelfSigned() const
787 {
788 Q_D(const CertificateInfo);
789 return d->is_self_signed;
790 }
791
792 QByteArray CertificateInfo::certificateData() const
793 {
794 Q_D(const CertificateInfo);
795 return d->certificate_der;
796 }
797
798 bool CertificateInfo::checkPassword(const QString &password) const
799 {
800 #if ENABLE_SIGNATURES
801 auto backend = CryptoSign::Factory::createActive();
802 if (!backend) {
803 return false;
804 }
805 Q_D(const CertificateInfo);
806 auto sigHandler = backend->createSigningHandler(d->nick_name.toStdString(), HashAlgorithm::Sha256);
807 unsigned char buffer[5];
808 memcpy(buffer, "test", 5);
809 sigHandler->addData(buffer, 5);
810 std::variant<std::vector<unsigned char>, CryptoSign::SigningErrorMessage> tmpSignature = sigHandler->signDetached(password.toStdString());
811 return std::holds_alternative<std::vector<unsigned char>>(tmpSignature);
812 #else
813 (void)password;
814 return false;
815 #endif
816 }
817
818 class SignatureValidationInfoPrivate
819 {
820 public:
821 explicit SignatureValidationInfoPrivate(CertificateInfo &&ci) : cert_info(ci) { }
822
823 SignatureValidationInfo::SignatureStatus signature_status;
824 SignatureValidationInfo::CertificateStatus certificate_status;
825 CertificateInfo cert_info;
826
827 QByteArray signature;
828 QString signer_name;
829 QString signer_subject_dn;
830 QString location;
831 QString reason;
832 HashAlgorithm hash_algorithm;
833 time_t signing_time;
834 QList<qint64> range_bounds;
835 qint64 docLength;
836 };
837
838 SignatureValidationInfo::SignatureValidationInfo(SignatureValidationInfoPrivate *priv) : d_ptr(priv) { }
839
840 SignatureValidationInfo::SignatureValidationInfo(const SignatureValidationInfo &other) = default;
841
842 SignatureValidationInfo::~SignatureValidationInfo() = default;
843
844 SignatureValidationInfo::SignatureStatus SignatureValidationInfo::signatureStatus() const
845 {
846 Q_D(const SignatureValidationInfo);
847 return d->signature_status;
848 }
849
850 SignatureValidationInfo::CertificateStatus SignatureValidationInfo::certificateStatus() const
851 {
852 Q_D(const SignatureValidationInfo);
853 return d->certificate_status;
854 }
855
856 QString SignatureValidationInfo::signerName() const
857 {
858 Q_D(const SignatureValidationInfo);
859 return d->signer_name;
860 }
861
862 QString SignatureValidationInfo::signerSubjectDN() const
863 {
864 Q_D(const SignatureValidationInfo);
865 return d->signer_subject_dn;
866 }
867
868 QString SignatureValidationInfo::location() const
869 {
870 Q_D(const SignatureValidationInfo);
871 return d->location;
872 }
873
874 QString SignatureValidationInfo::reason() const
875 {
876 Q_D(const SignatureValidationInfo);
877 return d->reason;
878 }
879
880 SignatureValidationInfo::HashAlgorithm SignatureValidationInfo::hashAlgorithm() const
881 {
882 #if ENABLE_SIGNATURES
883 Q_D(const SignatureValidationInfo);
884
885 switch (d->hash_algorithm) {
886 case ::HashAlgorithm::Md2:
887 return HashAlgorithmMd2;
888 case ::HashAlgorithm::Md5:
889 return HashAlgorithmMd5;
890 case ::HashAlgorithm::Sha1:
891 return HashAlgorithmSha1;
892 case ::HashAlgorithm::Sha256:
893 return HashAlgorithmSha256;
894 case ::HashAlgorithm::Sha384:
895 return HashAlgorithmSha384;
896 case ::HashAlgorithm::Sha512:
897 return HashAlgorithmSha512;
898 case ::HashAlgorithm::Sha224:
899 return HashAlgorithmSha224;
900 case ::HashAlgorithm::Unknown:
901 return HashAlgorithmUnknown;
902 }
903 #endif
904 return HashAlgorithmUnknown;
905 }
906
907 time_t SignatureValidationInfo::signingTime() const
908 {
909 Q_D(const SignatureValidationInfo);
910 return d->signing_time;
911 }
912
913 QByteArray SignatureValidationInfo::signature() const
914 {
915 Q_D(const SignatureValidationInfo);
916 return d->signature;
917 }
918
919 QList<qint64> SignatureValidationInfo::signedRangeBounds() const
920 {
921 Q_D(const SignatureValidationInfo);
922 return d->range_bounds;
923 }
924
925 bool SignatureValidationInfo::signsTotalDocument() const
926 {
927 Q_D(const SignatureValidationInfo);
928 if (d->range_bounds.size() == 4 && d->range_bounds.value(0) == 0 && d->range_bounds.value(1) >= 0 && d->range_bounds.value(2) > d->range_bounds.value(1) && d->range_bounds.value(3) >= d->range_bounds.value(2)) {
929 // The range from d->range_bounds.value(1) to d->range_bounds.value(2) is
930 // not authenticated by the signature and should only contain the signature
931 // itself padded with 0 bytes. This has been checked in readSignature().
932 // If it failed, d->signature is empty.
933 // A potential range after d->range_bounds.value(3) would be also not
934 // authenticated. Therefore d->range_bounds.value(3) should coincide with
935 // the end of the document.
936 if (d->docLength == d->range_bounds.value(3) && !d->signature.isEmpty()) {
937 return true;
938 }
939 }
940 return false;
941 }
942
943 CertificateInfo SignatureValidationInfo::certificateInfo() const
944 {
945 Q_D(const SignatureValidationInfo);
946 return d->cert_info;
947 }
948
949 SignatureValidationInfo &SignatureValidationInfo::operator=(const SignatureValidationInfo &other)
950 {
951 if (this != &other) {
952 d_ptr = other.d_ptr;
953 }
954
955 return *this;
956 }
957
958 FormFieldSignature::FormFieldSignature(DocumentData *doc, ::Page *p, ::FormWidgetSignature *w) : FormField(std::make_unique<FormFieldData>(doc, p, w)) { }
959
960 FormFieldSignature::~FormFieldSignature() = default;
961
962 FormField::FormType FormFieldSignature::type() const
963 {
964 return FormField::FormSignature;
965 }
966
967 FormFieldSignature::SignatureType FormFieldSignature::signatureType() const
968 {
969 SignatureType sigType = AdbePkcs7detached;
970 FormWidgetSignature *fws = static_cast<FormWidgetSignature *>(m_formData->fm);
971 switch (fws->signatureType()) {
972 case CryptoSign::SignatureType::adbe_pkcs7_sha1:
973 sigType = AdbePkcs7sha1;
974 break;
975 case CryptoSign::SignatureType::adbe_pkcs7_detached:
976 sigType = AdbePkcs7detached;
977 break;
978 case CryptoSign::SignatureType::ETSI_CAdES_detached:
979 sigType = EtsiCAdESdetached;
980 break;
981 case CryptoSign::SignatureType::unknown_signature_type:
982 sigType = UnknownSignatureType;
983 break;
984 case CryptoSign::SignatureType::unsigned_signature_field:
985 sigType = UnsignedSignature;
986 break;
987 case CryptoSign::SignatureType::g10c_pgp_signature_detached:
988 sigType = G10cPgpSignatureDetached;
989 break;
990 }
991 return sigType;
992 }
993
994 SignatureValidationInfo FormFieldSignature::validate(ValidateOptions opt) const
995 {
996 auto tempResult = validateAsync(opt);
997 tempResult.first.d_ptr->certificate_status = validateResult();
998 return tempResult.first;
999 }
1000
1001 static CertificateInfo::KeyLocation fromPopplerCore(KeyLocation location)
1002 {
1003 switch (location) {
1004 case KeyLocation::Computer:
1005 return CertificateInfo::KeyLocation::Computer;
1006 case KeyLocation::Other:
1007 return CertificateInfo::KeyLocation::Other;
1008 case KeyLocation::Unknown:
1009 return CertificateInfo::KeyLocation::Unknown;
1010 case KeyLocation::HardwareToken:
1011 return CertificateInfo::KeyLocation::HardwareToken;
1012 }
1013 return CertificateInfo::KeyLocation::Unknown;
1014 }
1015
1016 static CertificateInfo::CertificateType fromPopplerCore(CertificateType type)
1017 {
1018 switch (type) {
1019 case CertificateType::PGP:
1020 return CertificateInfo::CertificateType::PGP;
1021 case CertificateType::X509:
1022 return CertificateInfo::CertificateType::X509;
1023 }
1024 return CertificateInfo::CertificateType::X509; // fallback
1025 }
1026
1027 static CertificateInfoPrivate *createCertificateInfoPrivate(const X509CertificateInfo *ci)
1028 {
1029 CertificateInfoPrivate *certPriv = new CertificateInfoPrivate;
1030 certPriv->is_null = true;
1031 if (ci) {
1032 certPriv->version = ci->getVersion();
1033 certPriv->ku_extensions = ci->getKeyUsageExtensions();
1034 certPriv->keyLocation = fromPopplerCore(ci->getKeyLocation());
1035 certPriv->certificateType = fromPopplerCore(ci->getCertificateType());
1036
1037 const GooString &certSerial = ci->getSerialNumber();
1038 certPriv->serial_number = QByteArray(certSerial.c_str(), certSerial.size());
1039
1040 const X509CertificateInfo::EntityInfo &issuerInfo = ci->getIssuerInfo();
1041 certPriv->issuer_info.common_name = QString::fromStdString(issuerInfo.commonName);
1042 certPriv->issuer_info.distinguished_name = QString::fromStdString(issuerInfo.distinguishedName);
1043 certPriv->issuer_info.email_address = QString::fromStdString(issuerInfo.email);
1044 certPriv->issuer_info.org_name = QString::fromStdString(issuerInfo.organization);
1045
1046 const X509CertificateInfo::EntityInfo &subjectInfo = ci->getSubjectInfo();
1047 certPriv->subject_info.common_name = QString::fromStdString(subjectInfo.commonName);
1048 certPriv->subject_info.distinguished_name = QString::fromStdString(subjectInfo.distinguishedName);
1049 certPriv->subject_info.email_address = QString::fromStdString(subjectInfo.email);
1050 certPriv->subject_info.org_name = QString::fromStdString(subjectInfo.organization);
1051
1052 certPriv->nick_name = QString::fromStdString(ci->getNickName().toStr());
1053
1054 X509CertificateInfo::Validity certValidity = ci->getValidity();
1055 certPriv->validity_start = QDateTime::fromSecsSinceEpoch(certValidity.notBefore, QTimeZone::utc());
1056 certPriv->validity_end = QDateTime::fromSecsSinceEpoch(certValidity.notAfter, QTimeZone::utc());
1057
1058 const X509CertificateInfo::PublicKeyInfo &pkInfo = ci->getPublicKeyInfo();
1059 certPriv->public_key = QByteArray(pkInfo.publicKey.c_str(), pkInfo.publicKey.size());
1060 certPriv->public_key_type = static_cast<int>(pkInfo.publicKeyType);
1061 certPriv->public_key_strength = pkInfo.publicKeyStrength;
1062
1063 const GooString &certDer = ci->getCertificateDER();
1064 certPriv->certificate_der = QByteArray(certDer.c_str(), certDer.size());
1065
1066 certPriv->is_null = false;
1067 }
1068
1069 return certPriv;
1070 }
1071
1072 static SignatureValidationInfo::CertificateStatus fromInternal(CertificateValidationStatus status)
1073 {
1074 switch (status) {
1075 case CERTIFICATE_TRUSTED:
1076 return SignatureValidationInfo::CertificateTrusted;
1077 case CERTIFICATE_UNTRUSTED_ISSUER:
1078 return SignatureValidationInfo::CertificateUntrustedIssuer;
1079 case CERTIFICATE_UNKNOWN_ISSUER:
1080 return SignatureValidationInfo::CertificateUnknownIssuer;
1081 case CERTIFICATE_REVOKED:
1082 return SignatureValidationInfo::CertificateRevoked;
1083 case CERTIFICATE_EXPIRED:
1084 return SignatureValidationInfo::CertificateExpired;
1085 default:
1086 case CERTIFICATE_GENERIC_ERROR:
1087 return SignatureValidationInfo::CertificateGenericError;
1088 case CERTIFICATE_NOT_VERIFIED:
1089 return SignatureValidationInfo::CertificateNotVerified;
1090 }
1091 }
1092
1093 static SignatureValidationInfo fromInternal(SignatureInfo *si, FormWidgetSignature *fws)
1094 {
1095 // get certificate info
1096 const X509CertificateInfo *ci = si->getCertificateInfo();
1097 CertificateInfoPrivate *certPriv = createCertificateInfoPrivate(ci);
1098
1099 SignatureValidationInfoPrivate *priv = new SignatureValidationInfoPrivate(CertificateInfo(certPriv));
1100 switch (si->getSignatureValStatus()) {
1101 case SIGNATURE_VALID:
1102 priv->signature_status = SignatureValidationInfo::SignatureValid;
1103 break;
1104 case SIGNATURE_INVALID:
1105 priv->signature_status = SignatureValidationInfo::SignatureInvalid;
1106 break;
1107 case SIGNATURE_DIGEST_MISMATCH:
1108 priv->signature_status = SignatureValidationInfo::SignatureDigestMismatch;
1109 break;
1110 case SIGNATURE_DECODING_ERROR:
1111 priv->signature_status = SignatureValidationInfo::SignatureDecodingError;
1112 break;
1113 default:
1114 case SIGNATURE_GENERIC_ERROR:
1115 priv->signature_status = SignatureValidationInfo::SignatureGenericError;
1116 break;
1117 case SIGNATURE_NOT_FOUND:
1118 priv->signature_status = SignatureValidationInfo::SignatureNotFound;
1119 break;
1120 case SIGNATURE_NOT_VERIFIED:
1121 priv->signature_status = SignatureValidationInfo::SignatureNotVerified;
1122 break;
1123 }
1124 priv->certificate_status = SignatureValidationInfo::CertificateVerificationInProgress;
1125 priv->signer_name = QString::fromStdString(si->getSignerName());
1126 priv->signer_subject_dn = QString::fromStdString(si->getSubjectDN());
1127 priv->hash_algorithm = si->getHashAlgorithm();
1128 priv->location = UnicodeParsedString(si->getLocation().toStr());
1129 priv->reason = UnicodeParsedString(si->getReason().toStr());
1130
1131 priv->signing_time = si->getSigningTime();
1132 const std::vector<Goffset> ranges = fws->getSignedRangeBounds();
1133 if (!ranges.empty()) {
1134 for (Goffset bound : ranges) {
1135 priv->range_bounds.append(bound);
1136 }
1137 }
1138 std::optional<std::vector<unsigned char>> checkedSignature;
1139 std::tie(checkedSignature, priv->docLength) = fws->getCheckedSignature();
1140 if (priv->range_bounds.size() == 4 && checkedSignature) {
1141 priv->signature = QByteArray::fromRawData(reinterpret_cast<const char *>(checkedSignature->data()), checkedSignature->size());
1142 }
1143
1144 return SignatureValidationInfo(priv);
1145 }
1146
1147 SignatureValidationInfo FormFieldSignature::validate(int opt, const QDateTime &validationTime) const
1148 {
1149 auto tempResult = validateAsync(static_cast<ValidateOptions>(opt), validationTime);
1150 tempResult.first.d_ptr->certificate_status = validateResult();
1151 return tempResult.first;
1152 }
1153
1154 class AsyncObjectPrivate
1155 { /*Currently unused. Created for abi future proofing*/
1156 };
1157
1158 AsyncObject::AsyncObject() : QObject(nullptr) { }
1159
1160 AsyncObject::~AsyncObject() = default;
1161
1162 std::pair<SignatureValidationInfo, std::shared_ptr<Poppler::AsyncObject>> FormFieldSignature::validateAsync(ValidateOptions opt, const QDateTime &validationTime) const
1163 {
1164 auto object = std::make_shared<AsyncObject>();
1165 FormWidgetSignature *fws = static_cast<FormWidgetSignature *>(m_formData->fm);
1166 const time_t validationTimeT = validationTime.isValid() ? validationTime.toSecsSinceEpoch() : -1;
1167 SignatureInfo *si = fws->validateSignatureAsync(opt & ValidateVerifyCertificate, opt & ValidateForceRevalidation, validationTimeT, !(opt & ValidateWithoutOCSPRevocationCheck), opt & ValidateUseAIACertFetch,
1168 [obj = std::weak_ptr<AsyncObject>(object)]() {
1169 if (auto l = obj.lock()) {
1170 // We need to roundtrip over the eventloop
1171 // to ensure callers have a chance of connecting to AsyncObject::done
1172 QMetaObject::invokeMethod(
1173 l.get(),
1174 [innerObj = std::weak_ptr<AsyncObject>(l)]() {
1175 if (auto innerLocked = innerObj.lock()) {
1176 Q_EMIT innerLocked->done();
1177 }
1178 },
1179 Qt::QueuedConnection);
1180 }
1181 });
1182
1183 return { fromInternal(si, fws), object };
1184 }
1185
1186 SignatureValidationInfo::CertificateStatus FormFieldSignature::validateResult() const
1187 {
1188 return fromInternal(static_cast<FormWidgetSignature *>(m_formData->fm)->validateSignatureResult());
1189 }
1190
1191 ErrorString FormFieldSignature::lastSigningErrorDetails() const
1192 {
1193 return m_formData->lastSigningErrorDetails;
1194 }
1195
1196 FormFieldSignature::SigningResult FormFieldSignature::sign(const QString &outputFileName, const PDFConverter::NewSignatureData &data) const
1197 {
1198 FormWidgetSignature *fws = static_cast<FormWidgetSignature *>(m_formData->fm);
1199 if (fws->signatureType() != CryptoSign::SignatureType::unsigned_signature_field) {
1200 return FieldAlreadySigned;
1201 }
1202
1203 const auto [sig, file_size] = fws->getCheckedSignature();
1204 if (sig) {
1205 // the above unsigned_signature_field check
1206 // should already catch this, but double check
1207 return FieldAlreadySigned;
1208 }
1209 const auto reason = std::unique_ptr<GooString>(data.reason().isEmpty() ? nullptr : QStringToUnicodeGooString(data.reason()));
1210 const auto location = std::unique_ptr<GooString>(data.location().isEmpty() ? nullptr : QStringToUnicodeGooString(data.location()));
1211 const auto ownerPwd = std::optional<GooString>(data.documentOwnerPassword().constData());
1212 const auto userPwd = std::optional<GooString>(data.documentUserPassword().constData());
1213 const auto gSignatureText = std::unique_ptr<GooString>(QStringToUnicodeGooString(data.signatureText()));
1214 const auto gSignatureLeftText = std::unique_ptr<GooString>(QStringToUnicodeGooString(data.signatureLeftText()));
1215
1216 auto failure = fws->signDocumentWithAppearance(outputFileName.toStdString(), data.certNickname().toStdString(), data.password().toStdString(), reason.get(), location.get(), ownerPwd, userPwd, *gSignatureText, *gSignatureLeftText,
1217 data.fontSize(), data.leftFontSize(), convertQColor(data.fontColor()), data.borderWidth(), convertQColor(data.borderColor()), convertQColor(data.backgroundColor()));
1218 if (failure) {
1219 m_formData->lastSigningErrorDetails = fromPopplerCore(failure.value().message);
1220 switch (failure.value().type) {
1221 case CryptoSign::SigningError::GenericError:
1222 return GenericSigningError;
1223 case CryptoSign::SigningError::InternalError:
1224 return InternalError;
1225 case CryptoSign::SigningError::KeyMissing:
1226 return KeyMissing;
1227 case CryptoSign::SigningError::UserCancelled:
1228 return UserCancelled;
1229 case CryptoSign::SigningError::WriteFailed:
1230 return WriteFailed;
1231 case CryptoSign::SigningError::BadPassphrase:
1232 return BadPassphrase;
1233 }
1234 return GenericSigningError; // catch all
1235 } else {
1236 m_formData->lastSigningErrorDetails = {};
1237 return SigningSuccess;
1238 }
1239 }
1240
1241 bool hasNSSSupport()
1242 {
1243 #if ENABLE_NSS3
1244 return true;
1245 #else
1246 return false;
1247 #endif
1248 }
1249
1250 QVector<CertificateInfo> getAvailableSigningCertificates()
1251 {
1252 auto backend = CryptoSign::Factory::createActive();
1253 if (!backend) {
1254 return {};
1255 }
1256 QVector<CertificateInfo> vReturnCerts;
1257 std::vector<std::unique_ptr<X509CertificateInfo>> vCerts = backend->getAvailableSigningCertificates();
1258
1259 for (auto &cert : vCerts) {
1260 CertificateInfoPrivate *certPriv = createCertificateInfoPrivate(cert.get());
1261 vReturnCerts.append(CertificateInfo(certPriv));
1262 }
1263
1264 return vReturnCerts;
1265 }
1266
1267 static std::optional<CryptoSignBackend> convertToFrontend(std::optional<CryptoSign::Backend::Type> type)
1268 {
1269 if (!type) {
1270 return std::nullopt;
1271 }
1272 switch (type.value()) {
1273 case CryptoSign::Backend::Type::NSS3:
1274 return CryptoSignBackend::NSS;
1275 case CryptoSign::Backend::Type::GPGME:
1276 return CryptoSignBackend::GPG;
1277 }
1278 return std::nullopt;
1279 }
1280
1281 static std::optional<CryptoSign::Backend::Type> convertToBackend(std::optional<CryptoSignBackend> backend)
1282 {
1283 if (!backend) {
1284 return std::nullopt;
1285 }
1286 switch (backend.value()) {
1287 case CryptoSignBackend::NSS:
1288 return CryptoSign::Backend::Type::NSS3;
1289 case CryptoSignBackend::GPG:
1290 return CryptoSign::Backend::Type::GPGME;
1291 }
1292 return std::nullopt;
1293 }
1294
1295 QVector<CryptoSignBackend> availableCryptoSignBackends()
1296 {
1297 QVector<CryptoSignBackend> backends;
1298 for (auto &backend : CryptoSign::Factory::getAvailable()) {
1299 auto converted = convertToFrontend(backend);
1300 if (converted) {
1301 backends.push_back(converted.value());
1302 }
1303 }
1304 return backends;
1305 }
1306
1307 std::optional<CryptoSignBackend> activeCryptoSignBackend()
1308 {
1309 return convertToFrontend(CryptoSign::Factory::getActive());
1310 }
1311
1312 bool setActiveCryptoSignBackend(CryptoSignBackend backend)
1313 {
1314 auto available = availableCryptoSignBackends();
1315 if (!available.contains(backend)) {
1316 return false;
1317 }
1318 auto converted = convertToBackend(backend);
1319 if (!converted) {
1320 return false;
1321 }
1322 CryptoSign::Factory::setPreferredBackend(converted.value());
1323 return activeCryptoSignBackend() == backend;
1324 }
1325
1326 static bool hasNSSBackendFeature(CryptoSignBackendFeature feature)
1327 {
1328 switch (feature) {
1329 case CryptoSignBackendFeature::BackendAsksPassphrase:
1330 return false;
1331 }
1332 return false;
1333 }
1334
1335 static bool hasGPGBackendFeature(CryptoSignBackendFeature feature)
1336 {
1337 switch (feature) {
1338 case CryptoSignBackendFeature::BackendAsksPassphrase:
1339 return true;
1340 }
1341 return false;
1342 }
1343
1344 bool hasCryptoSignBackendFeature(CryptoSignBackend backend, CryptoSignBackendFeature feature)
1345 {
1346 switch (backend) {
1347 case CryptoSignBackend::NSS:
1348 return hasNSSBackendFeature(feature);
1349 case CryptoSignBackend::GPG:
1350 return hasGPGBackendFeature(feature);
1351 }
1352 return false;
1353 }
1354
1355 QString POPPLER_QT5_EXPORT getNSSDir()
1356 {
1357 #if ENABLE_NSS3
1358 return QString::fromLocal8Bit(NSSSignatureConfiguration::getNSSDir().c_str());
1359 #else
1360 return QString();
1361 #endif
1362 }
1363
1364 void setNSSDir(const QString &path)
1365 {
1366 #if ENABLE_NSS3
1367 if (path.isEmpty()) {
1368 return;
1369 }
1370
1371 const std::unique_ptr<GooString> goo = QStringToGooString(path);
1372 NSSSignatureConfiguration::setNSSDir(*goo);
1373 #else
1374 (void)path;
1375 #endif
1376 }
1377
1378 namespace {
1379 std::function<QString(const QString &)> nssPasswordCall;
1380 }
1381
1382 void setNSSPasswordCallback(const std::function<char *(const char *)> &f)
1383 {
1384 #if ENABLE_NSS3
1385 NSSSignatureConfiguration::setNSSPasswordCallback(f);
1386 #else
1387 qWarning() << "setNSSPasswordCallback called but this poppler is built without NSS support";
1388 (void)f;
1389 #endif
1390 }
1391
1392 void setPgpSignaturesAllowed(bool allowed)
1393 {
1394 #if ENABLE_GPGME
1395 GpgSignatureConfiguration::setPgpSignaturesAllowed(allowed);
1396 #else
1397 qWarning() << "Trying to enable pgp signatures, but pgp not enabled in this build";
1398 (void)allowed;
1399 #endif
1400 }
1401
1402 bool arePgpSignaturesAllowed()
1403 {
1404 #if ENABLE_GPGME
1405 return GpgSignatureConfiguration::arePgpSignaturesAllowed();
1406 #else
1407 return false;
1408 #endif
1409 }
1410 }