diff --git a/.gitignore b/.gitignore index 23f7f16..cdf5504 100644 --- a/.gitignore +++ b/.gitignore @@ -1,50 +1,52 @@ *.lo *.o .deps/ .libs/ /aclocal.m4 /autom4te.cache /config.h.in /config.h /config.log /config.status /configure /Makefile.in /VERSION autom4te.cache/ assuan/Makefile.in assuan/Makefile curses/Makefile.in curses/Makefile doc/Makefile.in doc/Makefile doc/pinentry.info doc/stamp-vti doc/version.texi efl/Makefile.in efl/Makefile fltk/Makefile.in fltk/Makefile gtk+-2/Makefile.in gtk+-2/Makefile gnome3/Makefile.in gnome3/Makefile pinentry/Makefile.in pinentry/Makefile qt/Makefile.in qt/Makefile qt/icons/Makefile.in qt/icons/Makefile +qt4/Makefile.in +qt4/Makefile tqt/Makefile.in tqt/Makefile secmem/Makefile.in secmem/Makefile w32/Makefile.in w32/Makefile tty/Makefile.in tty/Makefile /qt/pinentryconfirm.moc /qt/pinentrydialog.moc /qt/qsecurelineedit.moc /m4/Makefile.in /emacs/Makefile.in diff --git a/qt4/Makefile.am b/qt4/Makefile.am new file mode 100644 index 0000000..e4efc5d --- /dev/null +++ b/qt4/Makefile.am @@ -0,0 +1,62 @@ +# Makefile.am +# Copyright (C) 2002 g10 Code GmbH, Klarälvdalens Datakonsult AB +# Copyright (C) 2008, 2015 g10 Code GmbH +# +# This file is part of PINENTRY. +# +# PINENTRY is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# PINENTRY is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, see . +# SPDX-License-Identifier: GPL-2.0+ + +## Process this file with automake to produce Makefile.in + +bin_PROGRAMS = pinentry-qt + +EXTRA_DIST = document-encrypt.png pinentry.qrc + + +if FALLBACK_CURSES +ncurses_include = $(NCURSES_INCLUDE) +libcurses = ../pinentry/libpinentry-curses.a $(LIBCURSES) $(LIBICONV) +else +ncurses_include = +libcurses = +endif + + +AM_CPPFLAGS = $(COMMON_CFLAGS) \ + -I$(top_srcdir) -I$(top_srcdir)/secmem \ + $(ncurses_include) -I$(top_srcdir)/pinentry +AM_CXXFLAGS = $(PINENTRY_QT_CFLAGS) +pinentry_qt_LDADD = \ + ../pinentry/libpinentry.a $(top_builddir)/secmem/libsecmem.a \ + $(COMMON_LIBS) $(PINENTRY_QT_LIBS) $(libcurses) $(LIBCAP) +pinentry_qt_LDFLAGS = $(PINENTRY_QT_LDFLAGS) + +if BUILD_PINENTRY_QT +BUILT_SOURCES = \ + pinentryconfirm.moc pinentrydialog.moc pinlineedit.moc +endif + +CLEANFILES = \ + pinentryconfirm.moc pinentrydialog.moc pinlineedit.moc + +pinentry_qt_SOURCES = pinentrydialog.h pinentrydialog.cpp \ + main.cpp qrc_pinentry.cpp pinentryconfirm.cpp pinentryconfirm.h \ + pinlineedit.h pinlineedit.cpp + +nodist_pinentry_qt_SOURCES = \ + pinentryconfirm.moc pinentrydialog.moc pinlineedit.moc + +.h.moc: + $(MOC) `test -f '$<' || echo '$(srcdir)/'`$< -o $@ diff --git a/qt4/document-encrypt.png b/qt4/document-encrypt.png new file mode 100644 index 0000000..b80c2a6 Binary files /dev/null and b/qt4/document-encrypt.png differ diff --git a/qt4/main.cpp b/qt4/main.cpp new file mode 100644 index 0000000..bbcf226 --- /dev/null +++ b/qt4/main.cpp @@ -0,0 +1,401 @@ +/* main.cpp - A Qt dialog for PIN entry. + * Copyright (C) 2002, 2008 Klarälvdalens Datakonsult AB (KDAB) + * Copyright (C) 2003 g10 Code GmbH + * Copyright 2007 Ingo Klöcker + * + * Written by Steffen Hansen . + * Modified by Marcus Brinkmann . + * Modified by Marc Mutz + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see . + * SPDX-License-Identifier: GPL-2.0+ + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "pinentryconfirm.h" +#include "pinentrydialog.h" +#include "pinentry.h" + +#include +#include +#include +#include +#include +#include +#include +#if QT_VERSION >= 0x050000 +#include +#endif + +#include +#include +#include + +#include +#include + +#ifdef FALLBACK_CURSES +#include +#endif + +#if QT_VERSION >= 0x050000 && defined(QT_STATIC) + #include + #ifdef Q_OS_WIN + #include + #include + Q_IMPORT_PLUGIN(QWindowsIntegrationPlugin) + #elif defined(Q_OS_MAC) + Q_IMPORT_PLUGIN(QCocoaIntegrationPlugin) + #else + Q_IMPORT_PLUGIN(QXcbIntegrationPlugin) + #endif +#endif + +#ifdef Q_OS_WIN +#include +#endif + +static QString escape_accel(const QString &s) +{ + + QString result; + result.reserve(s.size()); + + bool afterUnderscore = false; + + for (unsigned int i = 0, end = s.size() ; i != end ; ++i) { + const QChar ch = s[i]; + if (ch == QLatin1Char('_')) { + if (afterUnderscore) { // escaped _ + result += QLatin1Char('_'); + afterUnderscore = false; + } else { // accel + afterUnderscore = true; + } + } else { + if (afterUnderscore || // accel + ch == QLatin1Char('&')) { // escape & from being interpreted by Qt + result += QLatin1Char('&'); + } + result += ch; + afterUnderscore = false; + } + } + + if (afterUnderscore) + // trailing single underscore: shouldn't happen, but deal with it robustly: + { + result += QLatin1Char('_'); + } + + return result; +} + +namespace +{ +class InvalidUtf8 : public std::invalid_argument +{ +public: + InvalidUtf8() : std::invalid_argument("invalid utf8") {} + ~InvalidUtf8() throw() {} +}; +} + +static const bool GPG_AGENT_IS_PORTED_TO_ONLY_SEND_UTF8 = false; + +static QString from_utf8(const char *s) +{ + const QString result = QString::fromUtf8(s); + if (result.contains(QChar::ReplacementCharacter)) { + if (GPG_AGENT_IS_PORTED_TO_ONLY_SEND_UTF8) { + throw InvalidUtf8(); + } else { + return QString::fromLocal8Bit(s); + } + } + + return result; +} + +static void +setup_foreground_window(QWidget *widget, WId parentWid) +{ +#if QT_VERSION >= 0x050000 + /* For windows set the desktop window as the transient parent */ + QWindow *parentWindow = nullptr; + if (parentWid) { + parentWindow = QWindow::fromWinId(parentWid); + } +#ifdef Q_OS_WIN + if (!parentWindow) { + HWND desktop = GetDesktopWindow(); + if (desktop) { + parentWindow = QWindow::fromWinId((WId) desktop); + } + } +#endif + if (parentWindow) { + // Ensure that we have a native wid + widget->winId(); + QWindow *wndHandle = widget->windowHandle(); + + if (wndHandle) { + wndHandle->setTransientParent(parentWindow); + } + } +#endif + widget->setWindowFlags(Qt::Window | + Qt::CustomizeWindowHint | + Qt::WindowTitleHint | + Qt::WindowCloseButtonHint | + Qt::WindowStaysOnTopHint | + Qt::WindowMinimizeButtonHint); +} + +static int +qt_cmd_handler(pinentry_t pe) +{ + char *str; + + int want_pass = !!pe->pin; + + const QString ok = + pe->ok ? escape_accel(from_utf8(pe->ok)) : + pe->default_ok ? escape_accel(from_utf8(pe->default_ok)) : + /* else */ QLatin1String("&OK") ; + const QString cancel = + pe->cancel ? escape_accel(from_utf8(pe->cancel)) : + pe->default_cancel ? escape_accel(from_utf8(pe->default_cancel)) : + /* else */ QLatin1String("&Cancel") ; + + str = pinentry_get_title (pe); + const QString title = + str ? from_utf8(str) : + /* else */ QLatin1String("pinentry-qt") ; + free (str); + + const QString repeatError = + pe->repeat_error_string ? from_utf8(pe->repeat_error_string) : + QLatin1String("Passphrases do not match"); + const QString repeatString = + pe->repeat_passphrase ? from_utf8(pe->repeat_passphrase) : + QString(); + const QString visibilityTT = + pe->default_tt_visi ? from_utf8(pe->default_tt_visi) : + QLatin1String("Show passphrase"); + const QString hideTT = + pe->default_tt_hide ? from_utf8(pe->default_tt_hide) : + QLatin1String("Hide passphrase"); + + const QString generateLbl = pe->genpin_label ? from_utf8(pe->genpin_label) : + QString(); + const QString generateTT = pe->genpin_tt ? from_utf8(pe->genpin_tt) : + QString(); + + + if (want_pass) { + char *str; + + PinEntryDialog pinentry(nullptr, 0, pe->timeout, true, !!pe->quality_bar, + repeatString, visibilityTT, hideTT); + setup_foreground_window(&pinentry, pe->parent_wid); + pinentry.setPinentryInfo(pe); + pinentry.setPrompt(escape_accel(from_utf8(pe->prompt))); + pinentry.setDescription(from_utf8(pe->description)); + pinentry.setRepeatErrorText(repeatError); + pinentry.setGenpinLabel(generateLbl); + pinentry.setGenpinTT(generateTT); + + str = pinentry_get_title (pe); + if (str) { + pinentry.setWindowTitle(from_utf8(str)); + free (str); + } + + /* If we reuse the same dialog window. */ + pinentry.setPin(QString()); + + pinentry.setOkText(ok); + pinentry.setCancelText(cancel); + if (pe->error) { + pinentry.setError(from_utf8(pe->error)); + } + if (pe->quality_bar) { + pinentry.setQualityBar(from_utf8(pe->quality_bar)); + } + if (pe->quality_bar_tt) { + pinentry.setQualityBarTT(from_utf8(pe->quality_bar_tt)); + } + bool ret = pinentry.exec(); + if (!ret) { + if (pinentry.timedOut()) + pe->specific_err = gpg_error (GPG_ERR_TIMEOUT); + return -1; + } + + const QString pinStr = pinentry.pin(); + QByteArray pin = pinStr.toUtf8(); + + if (!!pe->repeat_passphrase) { + /* Should not have been possible to accept + the dialog in that case but we do a safety + check here */ + pe->repeat_okay = (pinStr == pinentry.repeatedPin()); + } + + int len = strlen(pin.constData()); + if (len >= 0) { + pinentry_setbufferlen(pe, len + 1); + if (pe->pin) { + strcpy(pe->pin, pin.constData()); + return len; + } + } + return -1; + } else { + const QString desc = pe->description ? from_utf8(pe->description) : QString(); + const QString notok = pe->notok ? escape_accel(from_utf8(pe->notok)) : QString(); + + const QMessageBox::StandardButtons buttons = + pe->one_button ? QMessageBox::Ok : + pe->notok ? QMessageBox::Yes | QMessageBox::No | QMessageBox::Cancel : + /* else */ QMessageBox::Ok | QMessageBox::Cancel ; + + PinentryConfirm box(QMessageBox::Information, pe->timeout, title, desc, buttons, nullptr); + setup_foreground_window(&box, pe->parent_wid); + + const struct { + QMessageBox::StandardButton button; + QString label; + } buttonLabels[] = { + { QMessageBox::Ok, ok }, + { QMessageBox::Yes, ok }, + { QMessageBox::No, notok }, + { QMessageBox::Cancel, cancel }, + }; + + for (size_t i = 0 ; i < sizeof buttonLabels / sizeof * buttonLabels ; ++i) + if ((buttons & buttonLabels[i].button) && !buttonLabels[i].label.isEmpty()) { + box.button(buttonLabels[i].button)->setText(buttonLabels[i].label); +#ifndef QT_NO_ACCESSIBILITY + box.button(buttonLabels[i].button)->setAccessibleDescription(buttonLabels[i].label); +#endif + } + + box.setIconPixmap(icon()); + + if (!pe->one_button) { + box.setDefaultButton(QMessageBox::Cancel); + } + + box.show(); + raiseWindow(&box); + + const int rc = box.exec(); + + if (rc == QMessageBox::Cancel) { + pe->canceled = true; + } + if (box.timedOut()) { + pe->specific_err = gpg_error (GPG_ERR_TIMEOUT); + } + + return rc == QMessageBox::Ok || rc == QMessageBox::Yes ; + + } +} + +static int +qt_cmd_handler_ex(pinentry_t pe) +{ + try { + return qt_cmd_handler(pe); + } catch (const InvalidUtf8 &) { + pe->locale_err = true; + return pe->pin ? -1 : false ; + } catch (...) { + pe->canceled = true; + return pe->pin ? -1 : false ; + } +} + +pinentry_cmd_handler_t pinentry_cmd_handler = qt_cmd_handler_ex; + +int +main(int argc, char *argv[]) +{ + pinentry_init("pinentry-qt"); + + QApplication *app = NULL; + int new_argc = 0; + +#ifdef FALLBACK_CURSES + if (!pinentry_have_display(argc, argv)) { + pinentry_cmd_handler = curses_cmd_handler; + pinentry_set_flavor_flag ("curses"); + } else +#endif + { + /* Qt does only understand -display but not --display; thus we + are fixing that here. The code is pretty simply and may get + confused if an argument is called "--display". */ + char **new_argv, *p; + size_t n; + int i, done; + + for (n = 0, i = 0; i < argc; i++) { + n += strlen(argv[i]) + 1; + } + n++; + new_argv = (char **)calloc(argc + 1, sizeof * new_argv); + if (new_argv) { + *new_argv = (char *)malloc(n); + } + if (!new_argv || !*new_argv) { + fprintf(stderr, "pinentry-qt: can't fixup argument list: %s\n", + strerror(errno)); + exit(EXIT_FAILURE); + + } + for (done = 0, p = *new_argv, i = 0; i < argc; i++) + if (!done && !strcmp(argv[i], "--display")) { + new_argv[i] = strcpy(p, argv[i] + 1); + p += strlen(argv[i] + 1) + 1; + done = 1; + } else { + new_argv[i] = strcpy(p, argv[i]); + p += strlen(argv[i]) + 1; + } + + /* Note: QApplication uses int &argc so argc has to be valid + * for the full lifetime of the application. + * + * As Qt might modify argc / argv we use copies here so that + * we do not loose options that are handled in both. e.g. display. + */ + new_argc = argc; + Q_ASSERT (new_argc); + app = new QApplication(new_argc, new_argv); + app->setWindowIcon(QIcon(QLatin1String(":/document-encrypt.png"))); + } + + pinentry_parse_opts(argc, argv); + + int rc = pinentry_loop(); + delete app; + return rc ? EXIT_FAILURE : EXIT_SUCCESS ; +} diff --git a/qt4/pinentry.qrc b/qt4/pinentry.qrc new file mode 100644 index 0000000..94db054 --- /dev/null +++ b/qt4/pinentry.qrc @@ -0,0 +1,6 @@ + + + + document-encrypt.png + + diff --git a/qt4/pinentryconfirm.cpp b/qt4/pinentryconfirm.cpp new file mode 100644 index 0000000..65b191c --- /dev/null +++ b/qt4/pinentryconfirm.cpp @@ -0,0 +1,77 @@ +/* pinentryconfirm.cpp - A QMessageBox with a timeout + * + * Copyright (C) 2011 Ben Kibbey + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see . + * SPDX-License-Identifier: GPL-2.0+ + */ + +#include "pinentryconfirm.h" +#include "pinentrydialog.h" +#include +#include +#include +#include + +PinentryConfirm::PinentryConfirm(Icon icon, int timeout, const QString &title, + const QString &desc, StandardButtons buttons, QWidget *parent) : + QMessageBox(icon, title, desc, buttons, parent) +{ + _timed_out = false; + if (timeout > 0) { + _timer = new QTimer(this); + connect(_timer, SIGNAL(timeout()), this, SLOT(slotTimeout())); + _timer->start(timeout * 1000); + } +#ifndef QT_NO_ACCESSIBILITY + setAccessibleDescription(desc); + setAccessibleName(title); +#endif + raiseWindow(this); +} + +bool PinentryConfirm::timedOut() const +{ + return _timed_out; +} + +void PinentryConfirm::showEvent(QShowEvent *event) +{ + static bool resized; + if (!resized) { + QGridLayout* lay = dynamic_cast (layout()); + if (lay) { + QSize textSize = fontMetrics().size(Qt::TextExpandTabs, text(), fontMetrics().maxWidth()); + QSpacerItem* horizontalSpacer = new QSpacerItem(textSize.width() + iconPixmap().width(), + 0, QSizePolicy::Minimum, QSizePolicy::Expanding); + lay->addItem(horizontalSpacer, lay->rowCount(), 1, 1, lay->columnCount() - 1); + } + resized = true; + } + + QDialog::showEvent(event); + raiseWindow(this); +} + +void PinentryConfirm::slotTimeout() +{ + QAbstractButton *b = button(QMessageBox::Cancel); + _timed_out = true; + + if (b) { + b->animateClick(0); + } +} + +#include "pinentryconfirm.moc" diff --git a/qt4/pinentryconfirm.h b/qt4/pinentryconfirm.h new file mode 100644 index 0000000..ec116ac --- /dev/null +++ b/qt4/pinentryconfirm.h @@ -0,0 +1,46 @@ +/* pinentryconfirm.h - A QMessageBox with a timeout + * + * Copyright (C) 2011 Ben Kibbey + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see . + * SPDX-License-Identifier: GPL-2.0+ + */ + +#ifndef PINENTRYCONFIRM_H +#define PINENTRYCONFIRM_H + +#include +#include + +class PinentryConfirm : public QMessageBox +{ + Q_OBJECT +public: + PinentryConfirm(Icon, int timeout, const QString &title, + const QString &desc, StandardButtons buttons, + QWidget *parent); + bool timedOut() const; + +private slots: + void slotTimeout(); + +private: + QTimer *_timer; + bool _timed_out; + +protected: + /* reimp */ void showEvent(QShowEvent *event); +}; + +#endif diff --git a/qt4/pinentrydialog.cpp b/qt4/pinentrydialog.cpp new file mode 100644 index 0000000..1b2be36 --- /dev/null +++ b/qt4/pinentrydialog.cpp @@ -0,0 +1,511 @@ +/* pinentrydialog.cpp - A (not yet) secure Qt 4 dialog for PIN entry. + * Copyright (C) 2002, 2008 Klarälvdalens Datakonsult AB (KDAB) + * Copyright 2007 Ingo Klöcker + * Copyright 2016 Intevation GmbH + * + * Written by Steffen Hansen . + * Modified by Andre Heinecke + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see . + * SPDX-License-Identifier: GPL-2.0+ + */ + +#include "pinentrydialog.h" +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "pinlineedit.h" + +#include + +#ifdef Q_OS_WIN +#include +#if QT_VERSION >= 0x050700 +#include +#endif +#endif + +void raiseWindow(QWidget *w) +{ +#ifdef Q_OS_WIN +#if QT_VERSION >= 0x050700 + QWindowsWindowFunctions::setWindowActivationBehavior( + QWindowsWindowFunctions::AlwaysActivateWindow); +#endif +#endif + w->setWindowState((w->windowState() & ~Qt::WindowMinimized) | Qt::WindowActive); + w->activateWindow(); + w->raise(); +} + +QPixmap icon(QStyle::StandardPixmap which) +{ + QPixmap pm = qApp->windowIcon().pixmap(48, 48); + + if (which != QStyle::SP_CustomBase) { + const QIcon ic = qApp->style()->standardIcon(which); + QPainter painter(&pm); + const int emblemSize = 22; + painter.drawPixmap(pm.width() - emblemSize, 0, + ic.pixmap(emblemSize, emblemSize)); + } + + return pm; +} + +void PinEntryDialog::slotTimeout() +{ + _timed_out = true; + reject(); +} + +PinEntryDialog::PinEntryDialog(QWidget *parent, const char *name, + int timeout, bool modal, bool enable_quality_bar, + const QString &repeatString, + const QString &visibilityTT, + const QString &hideTT) + : QDialog(parent), + mRepeat(NULL), + _grabbed(false), + _disable_echo_allowed(true), + mVisibilityTT(visibilityTT), + mHideTT(hideTT), + mVisiActionEdit(NULL), + mGenerateActionEdit(NULL), + mVisiCB(NULL) +{ + _timed_out = false; + + if (modal) { + setWindowModality(Qt::ApplicationModal); + } + + _icon = new QLabel(this); + _icon->setPixmap(icon()); + + _error = new QLabel(this); + QPalette pal; + pal.setColor(QPalette::WindowText, Qt::red); + _error->setPalette(pal); + _error->hide(); + + _desc = new QLabel(this); + _desc->hide(); + + _prompt = new QLabel(this); + _prompt->hide(); + + _edit = new PinLineEdit(this); + _edit->setMaxLength(256); + _edit->setMinimumWidth(_edit->fontMetrics().averageCharWidth()*20 + 48); + _edit->setEchoMode(QLineEdit::Password); + + _prompt->setBuddy(_edit); + + if (enable_quality_bar) { + _quality_bar_label = new QLabel(this); + _quality_bar_label->setAlignment(Qt::AlignVCenter); + _quality_bar = new QProgressBar(this); + _quality_bar->setAlignment(Qt::AlignCenter); + _have_quality_bar = true; + } else { + _have_quality_bar = false; + } + + QDialogButtonBox *const buttons = new QDialogButtonBox(this); + buttons->setStandardButtons(QDialogButtonBox::Ok | QDialogButtonBox::Cancel); + _ok = buttons->button(QDialogButtonBox::Ok); + _cancel = buttons->button(QDialogButtonBox::Cancel); + + _ok->setDefault(true); + + if (style()->styleHint(QStyle::SH_DialogButtonBox_ButtonsHaveIcons)) { + _ok->setIcon(style()->standardIcon(QStyle::SP_DialogOkButton)); + _cancel->setIcon(style()->standardIcon(QStyle::SP_DialogCancelButton)); + } + + if (timeout > 0) { + _timer = new QTimer(this); + connect(_timer, SIGNAL(timeout()), this, SLOT(slotTimeout())); + _timer->start(timeout * 1000); + } else { + _timer = NULL; + } + + connect(buttons, SIGNAL(accepted()), this, SLOT(accept())); + connect(buttons, SIGNAL(rejected()), this, SLOT(reject())); + connect(_edit, SIGNAL(textChanged(QString)), + this, SLOT(updateQuality(QString))); + connect(_edit, SIGNAL(textChanged(QString)), + this, SLOT(textChanged(QString))); + connect(_edit, SIGNAL(backspacePressed()), + this, SLOT(onBackspace())); + + QGridLayout *const grid = new QGridLayout(this); + int row = 1; + grid->addWidget(_error, row++, 1, 1, 2); + grid->addWidget(_desc, row++, 1, 1, 2); + //grid->addItem( new QSpacerItem( 0, _edit->height() / 10, QSizePolicy::Minimum, QSizePolicy::Fixed ), 1, 1 ); + grid->addWidget(_prompt, row, 1); + grid->addWidget(_edit, row++, 2); + if (!repeatString.isNull()) { + mRepeat = new QLineEdit; + mRepeat->setMaxLength(256); + mRepeat->setEchoMode(QLineEdit::Password); + connect(mRepeat, SIGNAL(textChanged(QString)), + this, SLOT(textChanged(QString))); + QLabel *repeatLabel = new QLabel(repeatString); + repeatLabel->setBuddy(mRepeat); + grid->addWidget(repeatLabel, row, 1); + grid->addWidget(mRepeat, row++, 2); + setTabOrder(_edit, mRepeat); + setTabOrder(mRepeat, _ok); + } + if (enable_quality_bar) { + grid->addWidget(_quality_bar_label, row, 1); + grid->addWidget(_quality_bar, row++, 2); + } + /* Set up the show password action */ + const QIcon visibilityIcon = QIcon::fromTheme(QLatin1String("visibility")); + const QIcon hideIcon = QIcon::fromTheme(QLatin1String("hint")); + const QIcon generateIcon = QIcon(); /* Disabled for now + QIcon::fromTheme(QLatin1String("password-generate")); */ +#if QT_VERSION >= 0x050200 + if (!generateIcon.isNull()) { + mGenerateActionEdit = _edit->addAction(generateIcon, + QLineEdit::LeadingPosition); + mGenerateActionEdit->setToolTip(mGenerateTT); + connect(mGenerateActionEdit, SIGNAL(triggered()), this, SLOT(generatePin())); + } + if (!visibilityIcon.isNull() && !hideIcon.isNull()) { + mVisiActionEdit = _edit->addAction(visibilityIcon, QLineEdit::TrailingPosition); + mVisiActionEdit->setVisible(false); + mVisiActionEdit->setToolTip(mVisibilityTT); + connect(mVisiActionEdit, SIGNAL(triggered()), this, SLOT(toggleVisibility())); + } else +#endif + { + if (!mVisibilityTT.isNull()) { + mVisiCB = new QCheckBox(mVisibilityTT); + connect(mVisiCB, SIGNAL(toggled(bool)), this, SLOT(toggleVisibility())); + grid->addWidget(mVisiCB, row++, 1, 1, 2, Qt::AlignLeft); + } + } + grid->addWidget(buttons, ++row, 0, 1, 3); + + grid->addWidget(_icon, 0, 0, row - 1, 1, Qt::AlignVCenter | Qt::AlignLeft); + + grid->setSizeConstraint(QLayout::SetFixedSize); + + + connect(qApp, SIGNAL(focusChanged(QWidget *, QWidget *)), + this, SLOT(focusChanged(QWidget *, QWidget *))); + +#if QT_VERSION >= 0x050000 + /* This is mostly an issue on Windows where this results + in the pinentry popping up nicely with an animation and + comes to front. It is not ifdefed for Windows only since + window managers on Linux like KWin can also have this + result in an animation when the pinentry is shown and + not just popping it up. + */ + setWindowState(Qt::WindowMinimized); + QTimer::singleShot(0, this, [this] () { + raiseWindow (this); + }); +#else + activateWindow(); + raise(); +#endif +} + +void PinEntryDialog::showEvent(QShowEvent *event) +{ + QDialog::showEvent(event); + _edit->setFocus(); +} + +void PinEntryDialog::setDescription(const QString &txt) +{ + _desc->setVisible(!txt.isEmpty()); + _desc->setText(txt); +#ifndef QT_NO_ACCESSIBILITY + _desc->setAccessibleDescription(txt); +#endif + _icon->setPixmap(icon()); + setError(QString()); +} + +QString PinEntryDialog::description() const +{ + return _desc->text(); +} + +void PinEntryDialog::setError(const QString &txt) +{ + if (!txt.isNull()) { + _icon->setPixmap(icon(QStyle::SP_MessageBoxCritical)); + } + _error->setText(txt); +#ifndef QT_NO_ACCESSIBILITY + _error->setAccessibleDescription(txt); +#endif + _error->setVisible(!txt.isEmpty()); +} + +QString PinEntryDialog::error() const +{ + return _error->text(); +} + +void PinEntryDialog::setPin(const QString &txt) +{ + _edit->setText(txt); +} + +QString PinEntryDialog::pin() const +{ + return _edit->text(); +} + +void PinEntryDialog::setPrompt(const QString &txt) +{ + _prompt->setText(txt); + _prompt->setVisible(!txt.isEmpty()); + if (txt.contains("PIN")) + _disable_echo_allowed = false; +} + +QString PinEntryDialog::prompt() const +{ + return _prompt->text(); +} + +void PinEntryDialog::setOkText(const QString &txt) +{ + _ok->setText(txt); +#ifndef QT_NO_ACCESSIBILITY + _ok->setAccessibleDescription(txt); +#endif + _ok->setVisible(!txt.isEmpty()); +} + +void PinEntryDialog::setCancelText(const QString &txt) +{ + _cancel->setText(txt); +#ifndef QT_NO_ACCESSIBILITY + _cancel->setAccessibleDescription(txt); +#endif + _cancel->setVisible(!txt.isEmpty()); +} + +void PinEntryDialog::setQualityBar(const QString &txt) +{ + if (_have_quality_bar) { + _quality_bar_label->setText(txt); +#ifndef QT_NO_ACCESSIBILITY + _quality_bar_label->setAccessibleDescription(txt); +#endif + } +} + +void PinEntryDialog::setQualityBarTT(const QString &txt) +{ + if (_have_quality_bar) { + _quality_bar->setToolTip(txt); + } +} + +void PinEntryDialog::setGenpinLabel(const QString &txt) +{ + if (!mGenerateActionEdit) { + return; + } + if (txt.isEmpty()) { + mGenerateActionEdit->setVisible(false); + } else { + mGenerateActionEdit->setText(txt); + mGenerateActionEdit->setVisible(true); + } +} + +void PinEntryDialog::setGenpinTT(const QString &txt) +{ + if (mGenerateActionEdit) { + mGenerateActionEdit->setToolTip(txt); + } +} + +void PinEntryDialog::onBackspace() +{ + if (_disable_echo_allowed) { + _edit->setEchoMode(QLineEdit::NoEcho); + if (mRepeat) { + mRepeat->setEchoMode(QLineEdit::NoEcho); + } + } +} + +void PinEntryDialog::updateQuality(const QString &txt) +{ + int length; + int percent; + QPalette pal; + + if (_timer) { + _timer->stop(); + } + + _disable_echo_allowed = false; + + if (!_have_quality_bar || !_pinentry_info) { + return; + } + const QByteArray utf8_pin = txt.toUtf8(); + const char *pin = utf8_pin.constData(); + length = strlen(pin); + percent = length ? pinentry_inq_quality(_pinentry_info, pin, length) : 0; + if (!length) { + _quality_bar->reset(); + } else { + pal = _quality_bar->palette(); + if (percent < 0) { + pal.setColor(QPalette::Highlight, QColor("red")); + percent = -percent; + } else { + pal.setColor(QPalette::Highlight, QColor("green")); + } + _quality_bar->setPalette(pal); + _quality_bar->setValue(percent); + } +} + +void PinEntryDialog::setPinentryInfo(pinentry_t peinfo) +{ + _pinentry_info = peinfo; +} + +void PinEntryDialog::focusChanged(QWidget *old, QWidget *now) +{ + // Grab keyboard. It might be a little weird to do it here, but it works! + // Previously this code was in showEvent, but that did not work in Qt4. + if (!_pinentry_info || _pinentry_info->grab) { + if (_grabbed && old && (old == _edit || old == mRepeat)) { + old->releaseKeyboard(); + _grabbed = false; + } + if (!_grabbed && now && (now == _edit || now == mRepeat)) { + now->grabKeyboard(); + _grabbed = true; + } + } + +} + +void PinEntryDialog::textChanged(const QString &text) +{ + Q_UNUSED(text); + if (mRepeat && mRepeat->text() == _edit->text()) { + _ok->setEnabled(true); + _ok->setToolTip(QString()); + } else if (mRepeat) { + _ok->setEnabled(false); + _ok->setToolTip(mRepeatError); + } + + if (mVisiActionEdit && sender() == _edit) { + mVisiActionEdit->setVisible(!_edit->text().isEmpty()); + } + if (mGenerateActionEdit) { + mGenerateActionEdit->setVisible(_edit->text().isEmpty() && + _pinentry_info->genpin_label); + } +} + +void PinEntryDialog::generatePin() +{ + const char *pin = pinentry_inq_genpin(_pinentry_info); + if (pin) { + if (_edit->echoMode() == QLineEdit::Password) { + toggleVisibility(); + } + const auto pinStr = QString::fromUtf8(pin); + _edit->setText(pinStr); + mRepeat->setText(pinStr); + } +} + +void PinEntryDialog::toggleVisibility() +{ + if (sender() != mVisiCB) { + if (_edit->echoMode() == QLineEdit::Password) { + mVisiActionEdit->setIcon(QIcon::fromTheme(QLatin1String("hint"))); + mVisiActionEdit->setToolTip(mHideTT); + _edit->setEchoMode(QLineEdit::Normal); + if (mRepeat) { + mRepeat->setEchoMode(QLineEdit::Normal); + } + } else { + mVisiActionEdit->setIcon(QIcon::fromTheme(QLatin1String("visibility"))); + mVisiActionEdit->setToolTip(mVisibilityTT); + _edit->setEchoMode(QLineEdit::Password); + if (mRepeat) { + mRepeat->setEchoMode(QLineEdit::Password); + } + } + } else { + if (mVisiCB->isChecked()) { + if (mRepeat) { + mRepeat->setEchoMode(QLineEdit::Normal); + } + _edit->setEchoMode(QLineEdit::Normal); + } else { + if (mRepeat) { + mRepeat->setEchoMode(QLineEdit::Password); + } + _edit->setEchoMode(QLineEdit::Password); + } + } +} + +QString PinEntryDialog::repeatedPin() const +{ + if (mRepeat) { + return mRepeat->text(); + } + return QString(); +} + +bool PinEntryDialog::timedOut() const +{ + return _timed_out; +} + +void PinEntryDialog::setRepeatErrorText(const QString &err) +{ + mRepeatError = err; +} +#include "pinentrydialog.moc" diff --git a/qt4/pinentrydialog.h b/qt4/pinentrydialog.h new file mode 100644 index 0000000..45671b9 --- /dev/null +++ b/qt4/pinentrydialog.h @@ -0,0 +1,128 @@ +/* pinentrydialog.h - A (not yet) secure Qt 4 dialog for PIN entry. + * Copyright (C) 2002, 2008 Klarälvdalens Datakonsult AB (KDAB) + * Copyright 2007 Ingo Klöcker + * Copyright 2016 Intevation GmbH + * + * Written by Steffen Hansen . + * Modified by Andre Heinecke + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see . + * SPDX-License-Identifier: GPL-2.0+ + */ + +#ifndef __PINENTRYDIALOG_H__ +#define __PINENTRYDIALOG_H__ + +#include +#include +#include + +#include "pinentry.h" + +class QLabel; +class QPushButton; +class QLineEdit; +class PinLineEdit; +class QString; +class QProgressBar; +class QCheckBox; +class QAction; + +QPixmap icon(QStyle::StandardPixmap which = QStyle::SP_CustomBase); + +void raiseWindow(QWidget *w); + +class PinEntryDialog : public QDialog +{ + Q_OBJECT + + Q_PROPERTY(QString description READ description WRITE setDescription) + Q_PROPERTY(QString error READ error WRITE setError) + Q_PROPERTY(QString pin READ pin WRITE setPin) + Q_PROPERTY(QString prompt READ prompt WRITE setPrompt) +public: + explicit PinEntryDialog(QWidget *parent = 0, const char *name = 0, + int timeout = 0, bool modal = false, + bool enable_quality_bar = false, + const QString &repeatString = QString(), + const QString &visibiltyTT = QString(), + const QString &hideTT = QString()); + + void setDescription(const QString &); + QString description() const; + + void setError(const QString &); + QString error() const; + + void setPin(const QString &); + QString pin() const; + + QString repeatedPin() const; + void setRepeatErrorText(const QString &); + + void setPrompt(const QString &); + QString prompt() const; + + void setOkText(const QString &); + void setCancelText(const QString &); + + void setQualityBar(const QString &); + void setQualityBarTT(const QString &); + + void setGenpinLabel(const QString &); + void setGenpinTT(const QString &); + + void setPinentryInfo(pinentry_t); + + bool timedOut() const; + +protected slots: + void updateQuality(const QString &); + void slotTimeout(); + void textChanged(const QString &); + void focusChanged(QWidget *old, QWidget *now); + void toggleVisibility(); + void onBackspace(); + void generatePin(); + +protected: + /* reimp */ void showEvent(QShowEvent *event); + +private: + QLabel *_icon; + QLabel *_desc; + QLabel *_error; + QLabel *_prompt; + QLabel *_quality_bar_label; + QProgressBar *_quality_bar; + PinLineEdit *_edit; + QLineEdit *mRepeat; + QPushButton *_ok; + QPushButton *_cancel; + bool _grabbed; + bool _have_quality_bar; + bool _timed_out; + bool _disable_echo_allowed; + pinentry_t _pinentry_info; + QTimer *_timer; + QString mRepeatError, + mVisibilityTT, + mGenerateTT, + mHideTT; + QAction *mVisiActionEdit, + *mGenerateActionEdit; + QCheckBox *mVisiCB; +}; + +#endif // __PINENTRYDIALOG_H__ diff --git a/qt4/pinlineedit.cpp b/qt4/pinlineedit.cpp new file mode 100644 index 0000000..c7c7f36 --- /dev/null +++ b/qt4/pinlineedit.cpp @@ -0,0 +1,36 @@ +/* pinlineedit.cpp - Modified QLineEdit widget. + * Copyright (C) 2018 Damien Goutte-Gattat + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see . + * SPDX-License-Identifier: GPL-2.0+ + */ + +#include "pinlineedit.h" + +#include + +PinLineEdit::PinLineEdit(QWidget *parent) : QLineEdit(parent) +{ +} + +void +PinLineEdit::keyPressEvent(QKeyEvent *e) +{ + QLineEdit::keyPressEvent(e); + + if ( e->key() == Qt::Key::Key_Backspace ) + emit backspacePressed(); +} + +#include "pinlineedit.moc" diff --git a/qt4/pinlineedit.h b/qt4/pinlineedit.h new file mode 100644 index 0000000..b1b48df --- /dev/null +++ b/qt4/pinlineedit.h @@ -0,0 +1,38 @@ +/* pinlineedit.h - Modified QLineEdit widget. + * Copyright (C) 2018 Damien Goutte-Gattat + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see . + * SPDX-License-Identifier: GPL-2.0+ + */ + +#ifndef _PINLINEEDIT_H_ +#define _PINLINEEDIT_H_ + +#include + +class PinLineEdit : public QLineEdit +{ + Q_OBJECT + +public: + PinLineEdit(QWidget *); + +signals: + void backspacePressed(); + +protected: + void keyPressEvent(QKeyEvent *); +}; + +#endif // _PINLINEEDIT_H_ diff --git a/qt4/qrc_pinentry.cpp b/qt4/qrc_pinentry.cpp new file mode 100644 index 0000000..6ab2129 --- /dev/null +++ b/qt4/qrc_pinentry.cpp @@ -0,0 +1,177 @@ +/**************************************************************************** +** Resource object code +** +** Created: Wed Feb 17 23:35:02 2010 +** by: The Resource Compiler for Qt version 4.4.3 +** +** WARNING! All changes made in this file will be lost! +*****************************************************************************/ + +#include + +static const unsigned char qt_resource_data[] = { + // /home/marc/KDE/src/gnupg-backend/pinentry/qt4/document-encrypt.png + 0x0,0x0,0x7,0x2b, + 0x89, + 0x50,0x4e,0x47,0xd,0xa,0x1a,0xa,0x0,0x0,0x0,0xd,0x49,0x48,0x44,0x52,0x0, + 0x0,0x0,0x30,0x0,0x0,0x0,0x30,0x8,0x6,0x0,0x0,0x0,0x57,0x2,0xf9,0x87, + 0x0,0x0,0x0,0x4,0x73,0x42,0x49,0x54,0x8,0x8,0x8,0x8,0x7c,0x8,0x64,0x88, + 0x0,0x0,0x0,0x9,0x70,0x48,0x59,0x73,0x0,0x0,0x5,0x31,0x0,0x0,0x5,0x31, + 0x1,0xb7,0xed,0x28,0x52,0x0,0x0,0x0,0x19,0x74,0x45,0x58,0x74,0x53,0x6f,0x66, + 0x74,0x77,0x61,0x72,0x65,0x0,0x77,0x77,0x77,0x2e,0x69,0x6e,0x6b,0x73,0x63,0x61, + 0x70,0x65,0x2e,0x6f,0x72,0x67,0x9b,0xee,0x3c,0x1a,0x0,0x0,0x6,0xa8,0x49,0x44, + 0x41,0x54,0x78,0xda,0xd5,0x59,0x4b,0x6c,0x55,0x45,0x18,0xfe,0x67,0xce,0x7d,0xf5, + 0xfd,0xc0,0x82,0xb1,0xd,0xb,0xdd,0x11,0x34,0x46,0xd1,0xd,0x1b,0x42,0x4c,0x48, + 0x31,0xb4,0x68,0x52,0x16,0xb8,0x31,0xae,0x4c,0xec,0x92,0x85,0xa9,0x8b,0x6e,0x8c, + 0xb2,0x60,0xa9,0x21,0xee,0x5c,0xdb,0xf8,0x58,0xb9,0xa1,0x6d,0x60,0x61,0x42,0xb4, + 0xe0,0x2,0x41,0xd,0x8,0xd1,0xb6,0x94,0x36,0x5c,0xfb,0xa6,0xbd,0xf7,0x9e,0x73, + 0xc6,0xef,0xfb,0x73,0x99,0x73,0xe3,0xc5,0x40,0xd3,0x9e,0x5b,0x99,0xe4,0xe3,0x9f, + 0x33,0x33,0x67,0xce,0xff,0xfd,0xaf,0x99,0x72,0x8d,0x73,0x4e,0x9e,0xe6,0x96,0x91, + 0x14,0xda,0x8d,0x1b,0x37,0x72,0xd7,0xaf,0x5f,0x7f,0xb1,0x54,0x2a,0xbd,0xba,0xb9, + 0xb9,0xc9,0xa1,0x2b,0xb3,0xb3,0xb3,0xd7,0x46,0x47,0x47,0xcb,0xb2,0xc3,0x6d,0xc7, + 0x3c,0x30,0x3e,0x3e,0xbe,0xbf,0x52,0xa9,0x7c,0x8,0xa5,0x5f,0xc9,0x66,0xb3,0x2f, + 0x37,0x37,0x37,0xe7,0x3b,0x3a,0x3a,0xc4,0x5a,0x2b,0x2b,0x2b,0x2b,0xb2,0xbc,0xbc, + 0x5c,0xba,0x7f,0xff,0xfe,0x35,0xcc,0xff,0xb4,0x67,0xcf,0x9e,0xb3,0x43,0x43,0x43, + 0x7f,0xfd,0x6f,0x8,0x4c,0x4c,0x4c,0x7c,0x10,0x86,0xe1,0x68,0x6b,0x6b,0x6b,0x4f, + 0x77,0x77,0xb7,0xe4,0x72,0x39,0xe1,0xbe,0x4b,0x4b,0x4b,0x2a,0xf7,0xee,0xdd,0x2b, + 0x50,0x5a,0xc7,0x17,0x16,0x16,0xe4,0xd2,0xa5,0x4b,0x45,0x90,0x1c,0x3d,0x75,0xea, + 0xd4,0xe7,0xbb,0x4a,0x60,0x72,0x72,0xb2,0x17,0x8a,0x7f,0x89,0xee,0x1b,0x5d,0x5d, + 0x5d,0x2,0xf,0xc8,0xad,0x5b,0xb7,0x64,0x71,0x71,0x51,0x15,0x6f,0x6b,0x6b,0x13, + 0x63,0xc,0x3d,0xa0,0x63,0x50,0x5a,0xe,0x1e,0x3c,0x28,0xc7,0x8e,0x1d,0x93,0xa9, + 0xa9,0x29,0x29,0x16,0x8b,0xe3,0xed,0xed,0xed,0xef,0x1e,0x3d,0x7a,0x74,0xb6,0xe1, + 0x4,0xc6,0xc6,0xc6,0x72,0xb0,0xf6,0x1f,0xe8,0xf6,0xc1,0xf2,0x72,0xf7,0xee,0x5d, + 0x86,0x89,0x74,0x76,0x76,0x4a,0x14,0x45,0x12,0xc7,0xb1,0x80,0x9c,0xca,0x20,0x8, + 0x24,0x93,0xc9,0x28,0x90,0xb,0x32,0x3d,0x3d,0x2d,0xc3,0xc3,0xc3,0x3a,0x7f,0xf3, + 0xe6,0xcd,0x99,0xde,0xde,0xde,0x17,0xe,0x1c,0x38,0x50,0x6e,0x24,0x1,0x86,0xcd, + 0x37,0x78,0xf7,0xad,0x7c,0x3e,0x2f,0xb7,0x6f,0xdf,0x16,0xc4,0x3c,0xad,0x4e,0x8b, + 0xff,0xd,0xa5,0x3f,0x3,0xa6,0x40,0x64,0xea,0xc1,0x83,0x7,0x24,0x70,0xa8,0x5c, + 0x2e,0x1f,0x82,0x1c,0x46,0x5e,0x74,0x93,0xe0,0xd5,0xab,0x57,0x65,0x70,0x70,0x50, + 0xf0,0x3e,0x3d,0xf7,0xed,0xe1,0xc3,0x87,0xdf,0x6e,0x18,0x81,0xb,0x17,0x2e,0x1c, + 0x47,0x72,0x7e,0x7,0x8b,0x66,0x69,0x51,0x48,0x2a,0x41,0x12,0x5f,0x6d,0x6c,0x6c, + 0xbc,0x7f,0xfa,0xf4,0xe9,0x45,0x79,0x44,0x3b,0x7f,0xfe,0x7c,0x17,0xac,0xfe,0x5, + 0x3c,0x36,0x54,0x28,0x14,0xe4,0xf2,0xe5,0xcb,0x32,0x32,0x32,0x42,0x2f,0x84,0x20, + 0x3e,0x8,0x12,0xdf,0xa7,0x4e,0xe0,0xe2,0xc5,0x8b,0x19,0x28,0x39,0x3,0xcb,0xed, + 0xa3,0xd2,0xf3,0xf3,0xf3,0x6a,0x79,0xe4,0xc0,0xc8,0xc0,0xc0,0xc0,0xa7,0xf2,0x4, + 0xed,0xdc,0xb9,0x73,0x1f,0xf5,0xf4,0xf4,0x7c,0xbc,0xbe,0xbe,0xae,0x89,0xdd,0xdf, + 0xdf,0x2f,0x73,0x73,0x73,0xf3,0x6b,0x6b,0x6b,0x7d,0x47,0x8e,0x1c,0x9,0x65,0xb, + 0xcd,0x6e,0x91,0x30,0xe3,0xfc,0x24,0x3e,0xba,0x8f,0xc9,0x39,0x33,0x33,0xa3,0xf1, + 0xe,0x32,0xbf,0x42,0xf9,0xb3,0xf2,0x84,0xed,0xcc,0x99,0x33,0x9f,0x20,0xb1,0x7f, + 0x69,0x6a,0x6a,0xd2,0xdc,0x41,0x69,0xa5,0x7,0xf7,0x61,0xea,0x24,0x20,0x69,0x12, + 0x60,0xe2,0xf5,0xb3,0x9a,0xd0,0xea,0x54,0x9e,0x7,0x55,0x4b,0x4b,0xcb,0x9b,0x98, + 0xda,0x8a,0x2b,0x1d,0x94,0x1e,0x0,0x1c,0x3c,0xc7,0x83,0x8f,0x15,0x8a,0xf9,0xd3, + 0x9f,0x36,0x1,0x5a,0x8a,0xc9,0x28,0x48,0x4a,0x92,0xe1,0x47,0x57,0x4f,0x9c,0x38, + 0x71,0x47,0xb6,0xd6,0xe8,0x85,0x3b,0x78,0x7f,0x81,0x7b,0xdd,0xbb,0x77,0x4f,0xe8, + 0xd,0xe4,0xd5,0xa1,0xb4,0x9,0xb0,0x2c,0xf6,0x2,0xac,0xed,0x24,0xc1,0x4,0xfe, + 0xdd,0x4f,0x6e,0x7d,0xaf,0x6b,0xf4,0x22,0xf,0x37,0x96,0x62,0xb4,0xde,0xb4,0x9, + 0xd0,0x4a,0x9d,0xc,0x9f,0xd5,0xd5,0x55,0x12,0xe0,0x61,0x35,0xe9,0x27,0xb7,0xbe, + 0xd7,0xf,0xc,0x41,0x1a,0xa4,0xda,0x3a,0xd3,0x26,0xc0,0x90,0x9,0xf0,0x61,0x86, + 0xf,0xad,0xcf,0xa1,0x95,0x6d,0x10,0x58,0xe6,0x1e,0x2c,0x8,0xa8,0x40,0x1c,0xa, + 0xd2,0x23,0x50,0xff,0x71,0x3d,0x84,0xd8,0x76,0x62,0xf,0x5f,0xce,0x1b,0x45,0x0, + 0xc9,0xc7,0xc4,0xdb,0x2e,0x81,0x6d,0xef,0x91,0xd9,0xe,0x1,0x1e,0x42,0xdb,0x6d, + 0x3c,0x91,0x7d,0x6b,0xb0,0x7,0xfc,0xc7,0x53,0xda,0x23,0x7d,0x2,0x8c,0xdf,0x6d, + 0x36,0xee,0xf1,0xd4,0x12,0x60,0xe,0x30,0xc,0xd3,0xff,0x83,0xe6,0xc7,0xaf,0xdf, + 0x71,0x2f,0xbd,0xe6,0xa4,0x38,0xdd,0x2d,0x8b,0xc5,0x66,0xdc,0x5d,0x22,0x9e,0x1, + 0x1e,0x15,0x95,0x25,0xf6,0xeb,0x20,0xce,0xb1,0xdc,0x12,0xbc,0x2e,0x40,0xe1,0xbc, + 0xe4,0xf2,0x39,0x55,0x3c,0x8b,0x3e,0x25,0xd,0x41,0x14,0x9a,0x72,0xd2,0xdd,0xd7, + 0x25,0xd9,0x67,0x9c,0x5c,0x99,0xf8,0x59,0x8e,0xbf,0x37,0x66,0x76,0x2c,0x89,0x6d, + 0x26,0x94,0x67,0xf7,0xff,0x26,0xdd,0x1d,0x7f,0xca,0xc6,0x52,0x28,0xeb,0xeb,0x4d, + 0xb8,0x7,0x65,0x65,0x63,0xc3,0x0,0x56,0x36,0x36,0x45,0x4a,0x81,0x91,0x4d,0xeb, + 0xa4,0xa4,0x88,0x25,0xb,0x80,0x0,0x94,0x34,0x92,0x27,0xf2,0x84,0x95,0x2,0x1c, + 0x97,0x2f,0x20,0x81,0x5b,0x9c,0x34,0x17,0x80,0xf6,0xb2,0x74,0xf4,0x64,0xa5,0xe9, + 0xb9,0xd7,0xc5,0xb4,0x3d,0x2f,0xc5,0xb9,0x62,0x7a,0x55,0xc8,0x18,0x7,0x65,0x8a, + 0x92,0x33,0xeb,0x52,0xce,0xc4,0xb2,0x89,0x1d,0xd6,0x4c,0x20,0xad,0x90,0x65,0x44, + 0x43,0x58,0xe0,0x15,0x81,0xb0,0x12,0x58,0x86,0x1a,0xde,0x81,0xcc,0x6,0xec,0x43, + 0xe2,0x1d,0x95,0x58,0x97,0x6b,0x1,0x89,0x56,0x10,0x6c,0xc5,0x73,0x4b,0x9f,0x2e, + 0xc4,0x9b,0xc,0xad,0x74,0x8,0x50,0xa9,0x28,0x22,0x2,0x71,0x84,0x33,0x12,0x39, + 0xc6,0x32,0x89,0x19,0x82,0x4a,0x60,0xdc,0xa2,0xaf,0x74,0x1,0x84,0x90,0xce,0x13, + 0xb1,0x44,0x92,0xc1,0x12,0x23,0xb1,0xe5,0xd7,0x1d,0xd6,0xc6,0x80,0xc3,0x1c,0xde, + 0xe1,0x46,0x0,0xae,0x16,0xe9,0x10,0xb0,0x96,0xd6,0x73,0x30,0x25,0x3e,0x8a,0x8f, + 0x84,0xb4,0x96,0xe8,0x4c,0x95,0x0,0x3e,0xc,0x38,0x6b,0x34,0x74,0x38,0x19,0x83, + 0x44,0x88,0xe1,0x80,0xd6,0xd5,0x57,0x23,0x90,0xc7,0x32,0x40,0x42,0xc,0x68,0x1d, + 0xa8,0x0,0xbc,0xd9,0x2,0xd6,0xa6,0xe4,0x1,0xdf,0x9c,0xc4,0x80,0x8b,0x61,0xb5, + 0xc0,0xd1,0x60,0x0,0x65,0xa4,0x16,0x57,0xc3,0x1a,0xc7,0x2e,0x43,0x88,0xc4,0x54, + 0x5a,0x8c,0x5,0xec,0x63,0x5c,0x3,0x5,0x2f,0x3a,0x1a,0xc2,0x71,0x4d,0x6,0x32, + 0x20,0x68,0x98,0xd4,0x3c,0xe0,0xc3,0xa8,0xea,0x7f,0xc8,0x90,0xa,0x78,0x44,0x40, + 0x88,0xb9,0x58,0x17,0x92,0x26,0x63,0x5f,0x9f,0xc4,0xa8,0x53,0xac,0x5f,0x6b,0xa2, + 0x8,0x88,0x51,0x9d,0x1c,0x40,0x19,0x81,0x19,0x90,0xb6,0x7,0x18,0x46,0x21,0xc3, + 0xc4,0x44,0x4c,0x68,0x40,0x3c,0xb2,0x81,0xc6,0x35,0x74,0xd7,0xf0,0xf1,0x49,0x5c, + 0xcd,0x1,0xed,0x5b,0x63,0x28,0x81,0x98,0xde,0x21,0x4f,0xcd,0x29,0xb,0x18,0x1a, + 0x26,0x5d,0xf,0xf8,0xd0,0x96,0xd8,0x51,0x51,0x42,0x95,0xa8,0xc2,0xe8,0x58,0x54, + 0x55,0xc0,0xe9,0xba,0x2c,0x3d,0xa2,0x4a,0x87,0x21,0xc3,0xc9,0xe1,0x3c,0x88,0xa1, + 0xb0,0xd3,0x67,0x74,0x7d,0x75,0x13,0xd1,0x87,0x74,0x3d,0x60,0x4c,0x2d,0x8c,0xa2, + 0x36,0x3f,0xf8,0x64,0xf9,0xaf,0x4a,0x5a,0x3f,0xe4,0x70,0xd5,0x3,0xde,0x2b,0x55, + 0x90,0x8c,0x46,0x8d,0x42,0x14,0xb6,0x31,0xb7,0x51,0x63,0x34,0x79,0x21,0x1d,0xa4, + 0xa9,0x8b,0x71,0x6d,0xec,0x13,0x31,0xd7,0xea,0x9c,0xe,0x26,0x9c,0xd,0xbc,0x80, + 0xb9,0x10,0x79,0x0,0xaf,0xd9,0xf4,0xaf,0xd3,0xac,0xd1,0x55,0xe8,0x79,0x60,0x7c, + 0x8,0x51,0xb9,0x84,0x84,0xe6,0x8a,0xf7,0x54,0xc6,0x5b,0xd9,0x2b,0xf,0x19,0xd5, + 0x78,0x42,0x47,0xf0,0x9e,0x6e,0x90,0x26,0x81,0x58,0x15,0x73,0x80,0x9,0x20,0x81, + 0x87,0xa,0xc4,0x80,0xf,0x5,0xd1,0x40,0xaa,0x3b,0xc1,0xf9,0x2e,0xc7,0x95,0x84, + 0xca,0x8,0x48,0xc8,0x89,0x21,0x4c,0x63,0x42,0x28,0x49,0x5c,0xab,0x32,0xf1,0x2, + 0x51,0x1b,0x2a,0xc6,0xaf,0xe7,0x69,0x9b,0x9,0x9c,0x5f,0x1f,0x86,0x56,0x72,0x2e, + 0xd9,0x47,0x20,0xd1,0x69,0xc,0x1,0x6b,0x1f,0x22,0xae,0xb9,0x4a,0xd4,0x12,0x20, + 0xa1,0xc4,0xb,0xc9,0x5a,0x2d,0xa3,0x94,0x80,0xf8,0xbc,0xa8,0xae,0xda,0xb5,0x9f, + 0x98,0x18,0xbf,0x80,0xd4,0x82,0x25,0x93,0xe3,0xfe,0x0,0xa4,0x7,0x24,0x88,0x94, + 0x48,0x12,0xff,0x9,0x39,0x51,0xd8,0xc6,0x11,0x88,0x63,0x8f,0x5a,0x2b,0x7a,0xa5, + 0xd9,0xa2,0x88,0xb7,0x21,0xab,0xa7,0xad,0x88,0xc1,0xb3,0x55,0xeb,0x4b,0x5,0x28, + 0x63,0x75,0xe,0xa3,0x15,0xbd,0x5e,0x35,0xa2,0xa,0xd1,0xca,0xa,0xad,0x3e,0xf8, + 0x6c,0xd,0x91,0xa0,0x2e,0x17,0xd0,0x83,0xe2,0x3c,0x7d,0x35,0x79,0x6b,0xae,0x14, + 0x9a,0xd0,0x3c,0x3,0x38,0xaf,0x30,0x9c,0x48,0x9f,0x0,0x13,0x53,0xc1,0xaa,0xe1, + 0xe3,0x9f,0xa,0xb8,0x38,0xa2,0xf2,0xe8,0xf8,0x3c,0xd4,0x6b,0x83,0xf5,0x57,0x8a, + 0x8,0x10,0x26,0x31,0x43,0x9,0xf0,0x21,0x87,0x7e,0xc,0xb8,0xdd,0xfc,0x99,0xd5, + 0xd7,0x7f,0xf,0x25,0x61,0xab,0xca,0x9,0x9,0xb0,0x2f,0xc9,0x19,0x91,0x24,0x7d, + 0x42,0x64,0xb7,0x8,0x38,0x47,0xc4,0x2a,0x13,0xab,0xd6,0xa2,0x76,0x6d,0x1d,0x59, + 0xc0,0xed,0x2e,0x1,0x7f,0x18,0x29,0x1e,0x55,0x6a,0x3d,0x89,0xda,0xd2,0x5b,0x87, + 0x54,0xff,0x5b,0x25,0xfd,0xf6,0x14,0x12,0x48,0xe1,0x97,0x7a,0x5f,0xce,0x32,0x40, + 0xf0,0x18,0x58,0x2f,0x13,0x18,0x2f,0x89,0xfa,0xe6,0xaa,0x88,0xbd,0x4c,0x10,0x3d, + 0x94,0x8f,0x41,0x48,0x9d,0x6b,0x9,0x50,0xe9,0xa0,0xaa,0x74,0x96,0x72,0x87,0x61, + 0xab,0x8a,0x85,0x3b,0x88,0xa,0x50,0x66,0xff,0xbf,0x3c,0x60,0xeb,0x91,0x58,0xfd, + 0x31,0xb0,0x89,0xe2,0xa,0xa9,0xb3,0xb4,0x87,0x7f,0xe,0xeb,0x3d,0x50,0xef,0x1d, + 0xc2,0xfd,0x4b,0xe1,0x7f,0x0,0xd8,0x6e,0xc6,0xdd,0x5d,0xd6,0xb,0x18,0x0,0x0, + 0x0,0x0,0x49,0x45,0x4e,0x44,0xae,0x42,0x60,0x82, +}; + +static const unsigned char qt_resource_name[] = { + // document-encrypt.png + 0x0,0x14, + 0x8,0xbf,0x25,0x67, + 0x0,0x64, + 0x0,0x6f,0x0,0x63,0x0,0x75,0x0,0x6d,0x0,0x65,0x0,0x6e,0x0,0x74,0x0,0x2d,0x0,0x65,0x0,0x6e,0x0,0x63,0x0,0x72,0x0,0x79,0x0,0x70,0x0,0x74,0x0,0x2e, + 0x0,0x70,0x0,0x6e,0x0,0x67, +}; + +static const unsigned char qt_resource_struct[] = { + // : + 0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x1, + // :/document-encrypt.png + 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0, + +}; + +QT_BEGIN_NAMESPACE + +extern bool qRegisterResourceData + (int, const unsigned char *, const unsigned char *, const unsigned char *); + +extern bool qUnregisterResourceData + (int, const unsigned char *, const unsigned char *, const unsigned char *); + +QT_END_NAMESPACE + + +int QT_MANGLE_NAMESPACE(qInitResources_pinentry)() +{ + QT_PREPEND_NAMESPACE(qRegisterResourceData) + (0x01, qt_resource_struct, qt_resource_name, qt_resource_data); + return 1; +} + +Q_CONSTRUCTOR_FUNCTION(QT_MANGLE_NAMESPACE(qInitResources_pinentry)) + +int QT_MANGLE_NAMESPACE(qCleanupResources_pinentry)() +{ + QT_PREPEND_NAMESPACE(qUnregisterResourceData) + (0x01, qt_resource_struct, qt_resource_name, qt_resource_data); + return 1; +} + +Q_DESTRUCTOR_FUNCTION(QT_MANGLE_NAMESPACE(qCleanupResources_pinentry))