File indexing completed on 2024-12-01 04:21:58

 /*
  * Copyright (C) 2003-2008  Justin Karneges <justin@affinix.com>
  * Copyright (C) 2004,2005  Brad Hards <bradh@frogmouth.net>
  * Copyright (C) 2014-2016  Ivan Romanov <drizt@land.ru>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  *
  * This library 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
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  * 02110-1301  USA
  *
  */
 
 #include "qca_core.h"
 
 #include "qca_cert.h"
 #include "qca_keystore.h"
 #include "qca_plugin.h"
 #include "qca_textfilter.h"
 #include "qcaprovider.h"
 
 // for qAddPostRoutine
 #include <QCoreApplication>
 
 #include <QDir>
 #include <QMutex>
 #include <QSettings>
 #include <QVariantMap>
 #include <QWaitCondition>
 
 #ifdef Q_OS_UNIX
 #include <unistd.h>
 #endif
 
 int qcaVersion()
 {
     return QCA_VERSION;
 }
 
 const char *qcaVersionStr()
 {
     return QCA_VERSION_STR;
 }
 
 int qcaMajorVersion()
 {
     return QCA_MAJOR_VERSION;
 }
 
 int qcaMinorVersion()
 {
     return QCA_MINOR_VERSION;
 }
 
 int qcaPatchVersion()
 {
     return QCA_PATCH_VERSION;
 }
 
 namespace QCA {
 
 // from qca_tools
 bool botan_init(int prealloc, bool mmap);
 void botan_deinit();
 
 // from qca_default
 Provider *create_default_provider();
 
 //----------------------------------------------------------------------------
 // Global
 //----------------------------------------------------------------------------
 class Global
 {
 public:
     int                        refs;
     bool                       secmem;
     bool                       loaded;
     bool                       first_scan;
     QString                    app_name;
     QMutex                     name_mutex;
     ProviderManager           *manager;
     QMutex                     scan_mutex;
     Random                    *rng;
     QMutex                     rng_mutex;
     Logger                    *logger;
     QVariantMap                properties;
     QMutex                     prop_mutex;
     QMap<QString, QVariantMap> config;
     QMutex                     config_mutex;
     QMutex                     logger_mutex;
 
     Global()
     {
         refs       = 0;
         secmem     = false;
         loaded     = false;
         first_scan = false;
         rng        = nullptr;
         logger     = nullptr;
         manager    = new ProviderManager;
     }
 
     ~Global()
     {
         KeyStoreManager::shutdown();
         delete rng;
         rng = nullptr;
         delete manager;
         manager = nullptr;
         delete logger;
         logger = nullptr;
     }
 
     void ensure_loaded()
     {
         // probably we shouldn't overload scan mutex, or else rename it
         QMutexLocker locker(&scan_mutex);
         if (!loaded) {
             loaded = true;
             manager->setDefault(create_default_provider()); // manager owns it
         }
     }
 
     bool ensure_first_scan()
     {
         scan_mutex.lock();
         if (!first_scan) {
             first_scan = true;
             manager->scan();
             scan_mutex.unlock();
             return true;
         }
         scan_mutex.unlock();
         return false;
     }
 
     void scan()
     {
         scan_mutex.lock();
         first_scan = true;
         manager->scan();
         scan_mutex.unlock();
     }
 
     void ksm_scan()
     {
         KeyStoreManager::scan();
     }
 
     Logger *get_logger()
     {
         QMutexLocker locker(&logger_mutex);
         if (!logger) {
             logger = new Logger;
 
             // needed so deinit may delete the logger regardless
             //   of what thread the logger was created from
             logger->moveToThread(nullptr);
         }
         return logger;
     }
 
     void unloadAllPlugins()
     {
         KeyStoreManager::shutdown();
 
         // if the global_rng was owned by a plugin, then delete it
         rng_mutex.lock();
         if (rng && (rng->provider() != manager->find(QStringLiteral("default")))) {
             delete rng;
             rng = nullptr;
         }
         rng_mutex.unlock();
 
         manager->unloadAll();
     }
 };
 
 Q_GLOBAL_STATIC(QMutex, global_mutex)
 static Global *global = nullptr;
 
 static bool features_have(const QStringList &have, const QStringList &want)
 {
     foreach (const QString &i, want) {
         if (!have.contains(i))
             return false;
     }
     return true;
 }
 
 void init(MemoryMode mode, int prealloc)
 {
     QMutexLocker locker(global_mutex());
     if (global) {
         ++(global->refs);
         return;
     }
 
     bool allow_mmap_fallback = false;
     bool drop_root           = false;
     if (mode == Practical) {
         allow_mmap_fallback = true;
         drop_root           = true;
     } else if (mode == Locking)
         drop_root = true;
 
     bool secmem = botan_init(prealloc, allow_mmap_fallback);
 
 #if defined(Q_OS_UNIX)
     if ((geteuid() == 0) && drop_root) {
         setuid(getuid());
     }
 #endif
 
     global         = new Global;
     global->secmem = secmem;
     ++(global->refs);
 
     // for maximum setuid safety, qca should be initialized before qapp:
     //
     //   int main(int argc, char **argv)
     //   {
     //       QCA::Initializer init;
     //       QCoreApplication app(argc, argv);
     //       return 0;
     //   }
     //
     // however, the above code has the unfortunate side-effect of causing
     // qapp to deinit before qca, which can cause problems with any
     // plugins that have active objects (notably KeyStore).  we'll use a
     // post routine to force qca to deinit first.
     qAddPostRoutine(deinit);
 }
 
 void init()
 {
     init(Practical, 64);
 }
 
 void deinit()
 {
     QMutexLocker locker(global_mutex());
     if (!global)
         return;
     --(global->refs);
     if (global->refs == 0) {
         // In order to maintain symmetry with the init() function, remove the
         // post routine from QCoreApplication. This is needed in case when the
         // QCA library is unloaded before QCoreApplication instance completes:
         // QCoreApplication d-tor would try to execute the deinit() function,
         // which would no longer be there.
         // Note that this function is documented only in Qt 5.3 and later, but
         // it has been present since ancient times with the same semantics.
         qRemovePostRoutine(deinit);
 
         delete global;
         global = nullptr;
         botan_deinit();
     }
 }
 
 static bool global_check()
 {
     Q_ASSERT(global);
     if (!global)
         return false;
     return true;
 }
 
 static bool global_check_load()
 {
     Q_ASSERT(global);
     if (!global)
         return false;
     global->ensure_loaded();
     return true;
 }
 
 QMutex *global_random_mutex()
 {
     return &global->rng_mutex;
 }
 
 Random *global_random()
 {
     if (!global->rng)
         global->rng = new Random;
     return global->rng;
 }
 
 bool haveSecureMemory()
 {
     if (!global_check())
         return false;
 
     return global->secmem;
 }
 
 bool haveSecureRandom()
 {
     if (!global_check_load())
         return false;
 
     QMutexLocker locker(global_random_mutex());
     if (global_random()->provider()->name() != QLatin1String("default"))
         return true;
 
     return false;
 }
 
 bool isSupported(const QStringList &features, const QString &provider)
 {
     if (!global_check_load())
         return false;
 
     // single
     if (!provider.isEmpty()) {
         Provider *p = global->manager->find(provider);
         if (!p) {
             // ok, try scanning for new stuff
             global->scan();
             p = global->manager->find(provider);
         }
 
         if (p && features_have(p->features(), features))
             return true;
     }
     // all
     else {
         if (features_have(global->manager->allFeatures(), features))
             return true;
 
         global->manager->appendDiagnosticText(
             QStringLiteral("Scanning to find features: %1\n").arg(features.join(QStringLiteral(" "))));
 
         // ok, try scanning for new stuff
         global->scan();
 
         if (features_have(global->manager->allFeatures(), features))
             return true;
     }
     return false;
 }
 
 bool isSupported(const char *features, const QString &provider)
 {
     return isSupported(QString::fromLatin1(features).split(QLatin1Char(','), Qt::SkipEmptyParts), provider);
 }
 
 QStringList supportedFeatures()
 {
     if (!global_check_load())
         return QStringList();
 
     // query all features
     global->scan();
     return global->manager->allFeatures();
 }
 
 QStringList defaultFeatures()
 {
     if (!global_check_load())
         return QStringList();
 
     return global->manager->find(QStringLiteral("default"))->features();
 }
 
 ProviderList providers()
 {
     if (!global_check_load())
         return ProviderList();
 
     global->ensure_first_scan();
 
     return global->manager->providers();
 }
 
 bool insertProvider(Provider *p, int priority)
 {
     if (!global_check_load())
         return false;
 
     global->ensure_first_scan();
 
     return global->manager->add(p, priority);
 }
 
 bool unloadProvider(const QString &name)
 {
     if (!global_check_load())
         return false;
 
     global->ensure_first_scan();
 
     return global->manager->unload(name);
 }
 
 void setProviderPriority(const QString &name, int priority)
 {
     if (!global_check_load())
         return;
 
     global->ensure_first_scan();
 
     global->manager->changePriority(name, priority);
 }
 
 int providerPriority(const QString &name)
 {
     if (!global_check_load())
         return -1;
 
     global->ensure_first_scan();
 
     return global->manager->getPriority(name);
 }
 
 Provider *findProvider(const QString &name)
 {
     if (!global_check_load())
         return nullptr;
 
     global->ensure_first_scan();
 
     return global->manager->find(name);
 }
 
 Provider *defaultProvider()
 {
     if (!global_check_load())
         return nullptr;
 
     return global->manager->find(QStringLiteral("default"));
 }
 
 QStringList pluginPaths()
 {
     QStringList paths;
 #ifndef DEVELOPER_MODE
     const QByteArray qcaPluginPath = qgetenv("QCA_PLUGIN_PATH");
     if (!qcaPluginPath.isEmpty()) {
 #ifdef Q_OS_WIN
         char pathSep(';');
 #else
         char pathSep(':');
 #endif
         foreach (const QByteArray &path, qcaPluginPath.split(pathSep)) {
             const QString canonicalPath = QDir(QFile::decodeName(path)).canonicalPath();
             if (!canonicalPath.isEmpty())
                 paths << canonicalPath;
         }
     }
     paths += QCoreApplication::libraryPaths();
 #endif
     // In developer mode load plugins only from buildtree.
     // In regular mode QCA_PLUGIN_PATH is path where plugins was installed
     paths << QDir(QStringLiteral(QCA_PLUGIN_PATH)).canonicalPath();
 #ifndef DEVELOPER_MODE
     paths.removeDuplicates();
 #endif
     // No empty strings
     paths.removeAll(QString());
     return paths;
 }
 
 void scanForPlugins()
 {
     if (!global_check_load())
         return;
 
     global->scan();
     global->ksm_scan();
 }
 
 void unloadAllPlugins()
 {
     if (!global_check_load())
         return;
 
     global->unloadAllPlugins();
 }
 
 QString pluginDiagnosticText()
 {
     if (!global_check_load())
         return QString();
 
     return global->manager->diagnosticText();
 }
 
 void clearPluginDiagnosticText()
 {
     if (!global_check_load())
         return;
 
     global->manager->clearDiagnosticText();
 }
 
 void appendPluginDiagnosticText(const QString &text)
 {
     if (!global_check_load())
         return;
 
     global->manager->appendDiagnosticText(text);
 }
 
 void setProperty(const QString &name, const QVariant &value)
 {
     if (!global_check_load())
         return;
 
     QMutexLocker locker(&global->prop_mutex);
 
     global->properties[name] = value;
 }
 
 QVariant getProperty(const QString &name)
 {
     if (!global_check_load())
         return QVariant();
 
     QMutexLocker locker(&global->prop_mutex);
 
     return global->properties.value(name);
 }
 
 static bool configIsValid(const QVariantMap &config)
 {
     if (!config.contains(QStringLiteral("formtype")))
         return false;
     QMapIterator<QString, QVariant> it(config);
     while (it.hasNext()) {
         it.next();
         const QVariant &v = it.value();
 #if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
         if (v.typeId() != QMetaType::QString && v.typeId() != QMetaType::Int && v.typeId() != QMetaType::Bool)
 #else
         if (v.type() != QVariant::String && v.type() != QVariant::Int && v.type() != QVariant::Bool)
 
 #endif
             return false;
     }
     return true;
 }
 
 static QVariantMap readConfig(const QString &name)
 {
     QSettings settings(QStringLiteral("Affinix"), QStringLiteral("QCA2"));
     settings.beginGroup(QStringLiteral("ProviderConfig"));
     const QStringList providerNames = settings.value(QStringLiteral("providerNames")).toStringList();
     if (!providerNames.contains(name))
         return QVariantMap();
 
     settings.beginGroup(name);
     const QStringList keys = settings.childKeys();
     QVariantMap       map;
     foreach (const QString &key, keys)
         map[key] = settings.value(key);
     settings.endGroup();
 
     if (!configIsValid(map))
         return QVariantMap();
     return map;
 }
 
 static bool writeConfig(const QString &name, const QVariantMap &config, bool systemWide = false)
 {
     QSettings settings(QSettings::NativeFormat,
                        systemWide ? QSettings::SystemScope : QSettings::UserScope,
                        QStringLiteral("Affinix"),
                        QStringLiteral("QCA2"));
     settings.beginGroup(QStringLiteral("ProviderConfig"));
 
     // version
     settings.setValue(QStringLiteral("version"), 2);
 
     // add the entry if needed
     QStringList providerNames = settings.value(QStringLiteral("providerNames")).toStringList();
     if (!providerNames.contains(name))
         providerNames += name;
     settings.setValue(QStringLiteral("providerNames"), providerNames);
 
     settings.beginGroup(name);
     QMapIterator<QString, QVariant> it(config);
     while (it.hasNext()) {
         it.next();
         settings.setValue(it.key(), it.value());
     }
     settings.endGroup();
 
     if (settings.status() == QSettings::NoError)
         return true;
     return false;
 }
 
 void setProviderConfig(const QString &name, const QVariantMap &config)
 {
     if (!global_check_load())
         return;
 
     if (!configIsValid(config))
         return;
 
     global->config_mutex.lock();
     global->config[name] = config;
     global->config_mutex.unlock();
 
     Provider *p = findProvider(name);
     if (p)
         p->configChanged(config);
 }
 
 QVariantMap getProviderConfig(const QString &name)
 {
     if (!global_check_load())
         return QVariantMap();
 
     QVariantMap conf;
 
     global->config_mutex.lock();
 
     // try loading from persistent storage
     conf = readConfig(name);
 
     // if not, load the one from memory
     if (conf.isEmpty())
         conf = global->config.value(name);
 
     global->config_mutex.unlock();
 
     // if provider doesn't exist or doesn't have a valid config form,
     //   use the config we loaded
     Provider *p = findProvider(name);
     if (!p)
         return conf;
     const QVariantMap pconf = p->defaultConfig();
     if (!configIsValid(pconf))
         return conf;
 
     // if the config loaded was empty, use the provider's config
     if (conf.isEmpty())
         return pconf;
 
     // if the config formtype doesn't match the provider's formtype,
     //   then use the provider's
     if (pconf[QStringLiteral("formtype")] != conf[QStringLiteral("formtype")])
         return pconf;
 
     // otherwise, use the config loaded
     return conf;
 }
 
 void saveProviderConfig(const QString &name)
 {
     if (!global_check_load())
         return;
 
     QMutexLocker locker(&global->config_mutex);
 
     QVariantMap conf = global->config.value(name);
     if (conf.isEmpty())
         return;
 
     writeConfig(name, conf);
 }
 
 QVariantMap getProviderConfig_internal(Provider *p)
 {
     QVariantMap   conf;
     const QString name = p->name();
 
     global->config_mutex.lock();
 
     // try loading from persistent storage
     conf = readConfig(name);
 
     // if not, load the one from memory
     if (conf.isEmpty())
         conf = global->config.value(name);
 
     global->config_mutex.unlock();
 
     // if provider doesn't exist or doesn't have a valid config form,
     //   use the config we loaded
     const QVariantMap pconf = p->defaultConfig();
     if (!configIsValid(pconf))
         return conf;
 
     // if the config loaded was empty, use the provider's config
     if (conf.isEmpty())
         return pconf;
 
     // if the config formtype doesn't match the provider's formtype,
     //   then use the provider's
     if (pconf[QStringLiteral("formtype")] != conf[QStringLiteral("formtype")])
         return pconf;
 
     // otherwise, use the config loaded
     return conf;
 }
 
 QString globalRandomProvider()
 {
     QMutexLocker locker(global_random_mutex());
     return global_random()->provider()->name();
 }
 
 void setGlobalRandomProvider(const QString &provider)
 {
     QMutexLocker locker(global_random_mutex());
     delete global->rng;
     global->rng = new Random(provider);
 }
 
 Logger *logger()
 {
     return global->get_logger();
 }
 
 bool haveSystemStore()
 {
     // ensure the system store is loaded
     KeyStoreManager::start(QStringLiteral("default"));
     KeyStoreManager ksm;
     ksm.waitForBusyFinished();
 
     const QStringList list = ksm.keyStores();
     for (int n = 0; n < list.count(); ++n) {
         KeyStore ks(list[n], &ksm);
         if (ks.type() == KeyStore::System && ks.holdsTrustedCertificates())
             return true;
     }
     return false;
 }
 
 CertificateCollection systemStore()
 {
     // ensure the system store is loaded
     KeyStoreManager::start(QStringLiteral("default"));
     KeyStoreManager ksm;
     ksm.waitForBusyFinished();
 
     CertificateCollection col;
     const QStringList     list = ksm.keyStores();
     for (int n = 0; n < list.count(); ++n) {
         KeyStore ks(list[n], &ksm);
 
         // system store
         if (ks.type() == KeyStore::System && ks.holdsTrustedCertificates()) {
             // extract contents
             const QList<KeyStoreEntry> entries = ks.entryList();
             for (int i = 0; i < entries.count(); ++i) {
                 if (entries[i].type() == KeyStoreEntry::TypeCertificate)
                     col.addCertificate(entries[i].certificate());
                 else if (entries[i].type() == KeyStoreEntry::TypeCRL)
                     col.addCRL(entries[i].crl());
             }
             break;
         }
     }
     return col;
 }
 
 QString appName()
 {
     if (!global_check())
         return QString();
 
     QMutexLocker locker(&global->name_mutex);
 
     return global->app_name;
 }
 
 void setAppName(const QString &s)
 {
     if (!global_check())
         return;
 
     QMutexLocker locker(&global->name_mutex);
 
     global->app_name = s;
 }
 
 QString arrayToHex(const QByteArray &a)
 {
     return Hex().arrayToString(a);
 }
 
 QByteArray hexToArray(const QString &str)
 {
     return Hex().stringToArray(str).toByteArray();
 }
 
 QString arrayToBase64(const QByteArray &a)
 {
     return Base64().arrayToString(a);
 }
 
 QByteArray base64ToArray(const QString &base64String)
 {
     return Base64().stringToArray(base64String).toByteArray();
 }
 
 static Provider *getProviderForType(const QString &type, const QString &provider)
 {
     Provider *p       = nullptr;
     bool      scanned = global->ensure_first_scan();
     if (!provider.isEmpty()) {
         // try using specific provider
         p = global->manager->findFor(provider, type);
         if (!p && !scanned) {
             // maybe this provider is new, so scan and try again
             global->scan();
             scanned = true;
             p       = global->manager->findFor(provider, type);
         }
     }
     if (!p) {
         // try using some other provider
         p = global->manager->findFor(QString(), type);
 
         // note: we used to rescan if no provider was found or if
         //   the only found provider was 'default'.  now we only
         //   rescan if no provider was found.  this optimizes lookups
         //   for features that are in the default provider (such as
         //   'sha1') when no other plugin is available.  the drawback
         //   is that if a plugin is installed later during runtime,
         //   then it won't be picked up without restarting the
         //   application or manually calling QCA::scanForPlugins.
         // if((!p || p->name() == "default") && !scanned)
         if (!p && !scanned) {
             // maybe there are new providers, so scan and try again
             //   before giving up or using default
             global->scan();
             scanned = true;
             p       = global->manager->findFor(QString(), type);
         }
     }
 
     return p;
 }
 
 static inline Provider::Context *doCreateContext(Provider *p, const QString &type)
 {
     return p->createContext(type);
 }
 
 Provider::Context *getContext(const QString &type, const QString &provider)
 {
     if (!global_check_load())
         return nullptr;
 
     Provider *p;
     {
         p = getProviderForType(type, provider);
         if (!p)
             return nullptr;
     }
 
     return doCreateContext(p, type);
 }
 
 Provider::Context *getContext(const QString &type, Provider *_p)
 {
     if (!global_check_load())
         return nullptr;
 
     Provider *p;
     {
         p = global->manager->find(_p);
         if (!p)
             return nullptr;
     }
 
     return doCreateContext(p, type);
 }
 
 //----------------------------------------------------------------------------
 // Initializer
 //----------------------------------------------------------------------------
 Initializer::Initializer(MemoryMode m, int prealloc)
 {
     init(m, prealloc);
 }
 
 Initializer::~Initializer()
 {
     deinit();
 }
 
 //----------------------------------------------------------------------------
 // Provider
 //----------------------------------------------------------------------------
 Provider::~Provider()
 {
 }
 
 void Provider::init()
 {
 }
 
 void Provider::deinit()
 {
 }
 
 int Provider::version() const
 {
     return 0;
 }
 
 QString Provider::credit() const
 {
     return QString();
 }
 
 QVariantMap Provider::defaultConfig() const
 {
     return QVariantMap();
 }
 
 void Provider::configChanged(const QVariantMap &)
 {
 }
 
 Provider::Context::Context(Provider *parent, const QString &type)
     : QObject()
 {
     _provider = parent;
     _type     = type;
 }
 
 Provider::Context::Context(const Context &from)
     : QObject()
 {
     _provider = from._provider;
     _type     = from._type;
 }
 
 Provider::Context::~Context()
 {
 }
 
 Provider *Provider::Context::provider() const
 {
     return _provider;
 }
 
 QString Provider::Context::type() const
 {
     return _type;
 }
 
 bool Provider::Context::sameProvider(const Context *c) const
 {
     return (c->provider() == _provider);
 }
 
 //----------------------------------------------------------------------------
 // BasicContext
 //----------------------------------------------------------------------------
 BasicContext::BasicContext(Provider *parent, const QString &type)
     : Context(parent, type)
 {
     moveToThread(nullptr); // no thread association
 }
 
 BasicContext::BasicContext(const BasicContext &from)
     : Context(from)
 {
     moveToThread(nullptr); // no thread association
 }
 
 BasicContext::~BasicContext()
 {
 }
 
 //----------------------------------------------------------------------------
 // InfoContext
 //----------------------------------------------------------------------------
 QStringList InfoContext::supportedHashTypes() const
 {
     return QStringList();
 }
 
 QStringList InfoContext::supportedCipherTypes() const
 {
     return QStringList();
 }
 
 QStringList InfoContext::supportedMACTypes() const
 {
     return QStringList();
 }
 
 //----------------------------------------------------------------------------
 // PKeyBase
 //----------------------------------------------------------------------------
 PKeyBase::PKeyBase(Provider *p, const QString &type)
     : BasicContext(p, type)
 {
 }
 
 int PKeyBase::maximumEncryptSize(EncryptionAlgorithm) const
 {
     return 0;
 }
 
 SecureArray PKeyBase::encrypt(const SecureArray &, EncryptionAlgorithm)
 {
     return SecureArray();
 }
 
 bool PKeyBase::decrypt(const SecureArray &, SecureArray *, EncryptionAlgorithm)
 {
     return false;
 }
 
 void PKeyBase::startSign(SignatureAlgorithm, SignatureFormat)
 {
 }
 
 void PKeyBase::startVerify(SignatureAlgorithm, SignatureFormat)
 {
 }
 
 void PKeyBase::update(const MemoryRegion &)
 {
 }
 
 QByteArray PKeyBase::endSign()
 {
     return QByteArray();
 }
 
 bool PKeyBase::endVerify(const QByteArray &)
 {
     return false;
 }
 
 SymmetricKey PKeyBase::deriveKey(const PKeyBase &)
 {
     return SymmetricKey();
 }
 
 //----------------------------------------------------------------------------
 // PKeyContext
 //----------------------------------------------------------------------------
 QByteArray PKeyContext::publicToDER() const
 {
     return QByteArray();
 }
 
 QString PKeyContext::publicToPEM() const
 {
     return QString();
 }
 
 ConvertResult PKeyContext::publicFromDER(const QByteArray &)
 {
     return ErrorDecode;
 }
 
 ConvertResult PKeyContext::publicFromPEM(const QString &)
 {
     return ErrorDecode;
 }
 
 SecureArray PKeyContext::privateToDER(const SecureArray &, PBEAlgorithm) const
 {
     return SecureArray();
 }
 
 QString PKeyContext::privateToPEM(const SecureArray &, PBEAlgorithm) const
 {
     return QString();
 }
 
 ConvertResult PKeyContext::privateFromDER(const SecureArray &, const SecureArray &)
 {
     return ErrorDecode;
 }
 
 ConvertResult PKeyContext::privateFromPEM(const QString &, const SecureArray &)
 {
     return ErrorDecode;
 }
 
 //----------------------------------------------------------------------------
 // KeyStoreEntryContext
 //----------------------------------------------------------------------------
 bool KeyStoreEntryContext::isAvailable() const
 {
     return true;
 }
 
 KeyBundle KeyStoreEntryContext::keyBundle() const
 {
     return KeyBundle();
 }
 
 Certificate KeyStoreEntryContext::certificate() const
 {
     return Certificate();
 }
 
 CRL KeyStoreEntryContext::crl() const
 {
     return CRL();
 }
 
 PGPKey KeyStoreEntryContext::pgpSecretKey() const
 {
     return PGPKey();
 }
 
 PGPKey KeyStoreEntryContext::pgpPublicKey() const
 {
     return PGPKey();
 }
 
 bool KeyStoreEntryContext::ensureAccess()
 {
     return true;
 }
 
 //----------------------------------------------------------------------------
 // KeyStoreListContext
 //----------------------------------------------------------------------------
 void KeyStoreListContext::start()
 {
     QMetaObject::invokeMethod(this, "busyEnd", Qt::QueuedConnection);
 }
 
 void KeyStoreListContext::setUpdatesEnabled(bool)
 {
 }
 
 bool KeyStoreListContext::isReadOnly(int) const
 {
     return true;
 }
 
 KeyStoreEntryContext *KeyStoreListContext::entry(int id, const QString &entryId)
 {
     KeyStoreEntryContext         *out  = nullptr;
     QList<KeyStoreEntryContext *> list = entryList(id);
     for (int n = 0; n < list.count(); ++n) {
         if (list[n]->id() == entryId) {
             out = list.takeAt(n);
             break;
         }
     }
     qDeleteAll(list);
     return out;
 }
 
 KeyStoreEntryContext *KeyStoreListContext::entryPassive(const QString &serialized)
 {
     Q_UNUSED(serialized);
     return nullptr;
 }
 
 QString KeyStoreListContext::writeEntry(int, const KeyBundle &)
 {
     return QString();
 }
 
 QString KeyStoreListContext::writeEntry(int, const Certificate &)
 {
     return QString();
 }
 
 QString KeyStoreListContext::writeEntry(int, const CRL &)
 {
     return QString();
 }
 
 QString KeyStoreListContext::writeEntry(int, const PGPKey &)
 {
     return QString();
 }
 
 bool KeyStoreListContext::removeEntry(int, const QString &)
 {
     return false;
 }
 
 //----------------------------------------------------------------------------
 // TLSContext
 //----------------------------------------------------------------------------
 void TLSContext::setMTU(int)
 {
 }
 
 //----------------------------------------------------------------------------
 // MessageContext
 //----------------------------------------------------------------------------
 QString MessageContext::diagnosticText() const
 {
     return QString();
 }
 
 //----------------------------------------------------------------------------
 // SMSContext
 //----------------------------------------------------------------------------
 void SMSContext::setTrustedCertificates(const CertificateCollection &)
 {
 }
 
 void SMSContext::setUntrustedCertificates(const CertificateCollection &)
 {
 }
 
 void SMSContext::setPrivateKeys(const QList<SecureMessageKey> &)
 {
 }
 
 //----------------------------------------------------------------------------
 // BufferedComputation
 //----------------------------------------------------------------------------
 BufferedComputation::~BufferedComputation()
 {
 }
 
 MemoryRegion BufferedComputation::process(const MemoryRegion &a)
 {
     clear();
     update(a);
     return final();
 }
 
 //----------------------------------------------------------------------------
 // Filter
 //----------------------------------------------------------------------------
 Filter::~Filter()
 {
 }
 
 MemoryRegion Filter::process(const MemoryRegion &a)
 {
     clear();
     MemoryRegion buf = update(a);
     if (!ok())
         return MemoryRegion();
     const MemoryRegion fin = final();
     if (!ok())
         return MemoryRegion();
     if (buf.isSecure() || fin.isSecure())
         return (SecureArray(buf) + SecureArray(fin));
     else
         return QByteArray(buf.toByteArray() + fin.toByteArray());
 }
 
 //----------------------------------------------------------------------------
 // Algorithm
 //----------------------------------------------------------------------------
 class Algorithm::Private : public QSharedData
 {
 public:
     Provider::Context *c;
 
     Private(Provider::Context *context)
     {
         c = context;
         // printf("** [%p] Algorithm Created\n", c);
     }
 
     Private(const Private &from)
         : QSharedData(from)
     {
         c = from.c->clone();
         // printf("** [%p] Algorithm Copied (to [%p])\n", from.c, c);
     }
 
     ~Private()
     {
         // printf("** [%p] Algorithm Destroyed\n", c);
         delete c;
     }
 };
 
 Algorithm::Algorithm()
 {
 }
 
 Algorithm::Algorithm(const QString &type, const QString &provider)
 {
     change(type, provider);
 }
 
 Algorithm::Algorithm(const Algorithm &from)
 {
     *this = from;
 }
 
 Algorithm::~Algorithm()
 {
 }
 
 Algorithm &Algorithm::operator=(const Algorithm &from)
 {
     d = from.d;
     return *this;
 }
 
 QString Algorithm::type() const
 {
     if (d)
         return d->c->type();
     else
         return QString();
 }
 
 Provider *Algorithm::provider() const
 {
     if (d)
         return d->c->provider();
     else
         return nullptr;
 }
 
 Provider::Context *Algorithm::context()
 {
     if (d)
         return d->c;
     else
         return nullptr;
 }
 
 const Provider::Context *Algorithm::context() const
 {
     if (d)
         return d->c;
     else
         return nullptr;
 }
 
 void Algorithm::change(Provider::Context *c)
 {
     if (c)
         d = new Private(c);
     else
         d = nullptr;
 }
 
 void Algorithm::change(const QString &type, const QString &provider)
 {
     if (!type.isEmpty())
         change(getContext(type, provider));
     else
         change(nullptr);
 }
 
 Provider::Context *Algorithm::takeContext()
 {
     if (d) {
         Provider::Context *c = d->c; // should cause a detach
         d->c                 = nullptr;
         d                    = nullptr;
         return c;
     } else
         return nullptr;
 }
 
 //----------------------------------------------------------------------------
 // SymmetricKey
 //----------------------------------------------------------------------------
 SymmetricKey::SymmetricKey()
 {
 }
 
 SymmetricKey::SymmetricKey(int size)
 {
     set(Random::randomArray(size));
 }
 
 SymmetricKey::SymmetricKey(const SecureArray &a)
 {
     set(a);
 }
 
 SymmetricKey::SymmetricKey(const QByteArray &a)
 {
     set(SecureArray(a));
 }
 
 /* from libgcrypt-1.2.0 */
 static const unsigned char desWeakKeyTable[64][8] = {
     {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /*w*/
     {0x00, 0x00, 0x1e, 0x1e, 0x00, 0x00, 0x0e, 0x0e}, {0x00, 0x00, 0xe0, 0xe0, 0x00, 0x00, 0xf0, 0xf0},
     {0x00, 0x00, 0xfe, 0xfe, 0x00, 0x00, 0xfe, 0xfe}, {0x00, 0x1e, 0x00, 0x1e, 0x00, 0x0e, 0x00, 0x0e}, /*sw*/
     {0x00, 0x1e, 0x1e, 0x00, 0x00, 0x0e, 0x0e, 0x00}, {0x00, 0x1e, 0xe0, 0xfe, 0x00, 0x0e, 0xf0, 0xfe},
     {0x00, 0x1e, 0xfe, 0xe0, 0x00, 0x0e, 0xfe, 0xf0}, {0x00, 0xe0, 0x00, 0xe0, 0x00, 0xf0, 0x00, 0xf0}, /*sw*/
     {0x00, 0xe0, 0x1e, 0xfe, 0x00, 0xf0, 0x0e, 0xfe}, {0x00, 0xe0, 0xe0, 0x00, 0x00, 0xf0, 0xf0, 0x00},
     {0x00, 0xe0, 0xfe, 0x1e, 0x00, 0xf0, 0xfe, 0x0e}, {0x00, 0xfe, 0x00, 0xfe, 0x00, 0xfe, 0x00, 0xfe}, /*sw*/
     {0x00, 0xfe, 0x1e, 0xe0, 0x00, 0xfe, 0x0e, 0xf0}, {0x00, 0xfe, 0xe0, 0x1e, 0x00, 0xfe, 0xf0, 0x0e},
     {0x00, 0xfe, 0xfe, 0x00, 0x00, 0xfe, 0xfe, 0x00}, {0x1e, 0x00, 0x00, 0x1e, 0x0e, 0x00, 0x00, 0x0e},
     {0x1e, 0x00, 0x1e, 0x00, 0x0e, 0x00, 0x0e, 0x00}, /*sw*/
     {0x1e, 0x00, 0xe0, 0xfe, 0x0e, 0x00, 0xf0, 0xfe}, {0x1e, 0x00, 0xfe, 0xe0, 0x0e, 0x00, 0xfe, 0xf0},
     {0x1e, 0x1e, 0x00, 0x00, 0x0e, 0x0e, 0x00, 0x00}, {0x1e, 0x1e, 0x1e, 0x1e, 0x0e, 0x0e, 0x0e, 0x0e}, /*w*/
     {0x1e, 0x1e, 0xe0, 0xe0, 0x0e, 0x0e, 0xf0, 0xf0}, {0x1e, 0x1e, 0xfe, 0xfe, 0x0e, 0x0e, 0xfe, 0xfe},
     {0x1e, 0xe0, 0x00, 0xfe, 0x0e, 0xf0, 0x00, 0xfe}, {0x1e, 0xe0, 0x1e, 0xe0, 0x0e, 0xf0, 0x0e, 0xf0}, /*sw*/
     {0x1e, 0xe0, 0xe0, 0x1e, 0x0e, 0xf0, 0xf0, 0x0e}, {0x1e, 0xe0, 0xfe, 0x00, 0x0e, 0xf0, 0xfe, 0x00},
     {0x1e, 0xfe, 0x00, 0xe0, 0x0e, 0xfe, 0x00, 0xf0}, {0x1e, 0xfe, 0x1e, 0xfe, 0x0e, 0xfe, 0x0e, 0xfe}, /*sw*/
     {0x1e, 0xfe, 0xe0, 0x00, 0x0e, 0xfe, 0xf0, 0x00}, {0x1e, 0xfe, 0xfe, 0x1e, 0x0e, 0xfe, 0xfe, 0x0e},
     {0xe0, 0x00, 0x00, 0xe0, 0xf0, 0x00, 0x00, 0xf0}, {0xe0, 0x00, 0x1e, 0xfe, 0xf0, 0x00, 0x0e, 0xfe},
     {0xe0, 0x00, 0xe0, 0x00, 0xf0, 0x00, 0xf0, 0x00}, /*sw*/
     {0xe0, 0x00, 0xfe, 0x1e, 0xf0, 0x00, 0xfe, 0x0e}, {0xe0, 0x1e, 0x00, 0xfe, 0xf0, 0x0e, 0x00, 0xfe},
     {0xe0, 0x1e, 0x1e, 0xe0, 0xf0, 0x0e, 0x0e, 0xf0}, {0xe0, 0x1e, 0xe0, 0x1e, 0xf0, 0x0e, 0xf0, 0x0e}, /*sw*/
     {0xe0, 0x1e, 0xfe, 0x00, 0xf0, 0x0e, 0xfe, 0x00}, {0xe0, 0xe0, 0x00, 0x00, 0xf0, 0xf0, 0x00, 0x00},
     {0xe0, 0xe0, 0x1e, 0x1e, 0xf0, 0xf0, 0x0e, 0x0e}, {0xe0, 0xe0, 0xe0, 0xe0, 0xf0, 0xf0, 0xf0, 0xf0}, /*w*/
     {0xe0, 0xe0, 0xfe, 0xfe, 0xf0, 0xf0, 0xfe, 0xfe}, {0xe0, 0xfe, 0x00, 0x1e, 0xf0, 0xfe, 0x00, 0x0e},
     {0xe0, 0xfe, 0x1e, 0x00, 0xf0, 0xfe, 0x0e, 0x00}, {0xe0, 0xfe, 0xe0, 0xfe, 0xf0, 0xfe, 0xf0, 0xfe}, /*sw*/
     {0xe0, 0xfe, 0xfe, 0xe0, 0xf0, 0xfe, 0xfe, 0xf0}, {0xfe, 0x00, 0x00, 0xfe, 0xfe, 0x00, 0x00, 0xfe},
     {0xfe, 0x00, 0x1e, 0xe0, 0xfe, 0x00, 0x0e, 0xf0}, {0xfe, 0x00, 0xe0, 0x1e, 0xfe, 0x00, 0xf0, 0x0e},
     {0xfe, 0x00, 0xfe, 0x00, 0xfe, 0x00, 0xfe, 0x00}, /*sw*/
     {0xfe, 0x1e, 0x00, 0xe0, 0xfe, 0x0e, 0x00, 0xf0}, {0xfe, 0x1e, 0x1e, 0xfe, 0xfe, 0x0e, 0x0e, 0xfe},
     {0xfe, 0x1e, 0xe0, 0x00, 0xfe, 0x0e, 0xf0, 0x00}, {0xfe, 0x1e, 0xfe, 0x1e, 0xfe, 0x0e, 0xfe, 0x0e}, /*sw*/
     {0xfe, 0xe0, 0x00, 0x1e, 0xfe, 0xf0, 0x00, 0x0e}, {0xfe, 0xe0, 0x1e, 0x00, 0xfe, 0xf0, 0x0e, 0x00},
     {0xfe, 0xe0, 0xe0, 0xfe, 0xfe, 0xf0, 0xf0, 0xfe}, {0xfe, 0xe0, 0xfe, 0xe0, 0xfe, 0xf0, 0xfe, 0xf0}, /*sw*/
     {0xfe, 0xfe, 0x00, 0x00, 0xfe, 0xfe, 0x00, 0x00}, {0xfe, 0xfe, 0x1e, 0x1e, 0xfe, 0xfe, 0x0e, 0x0e},
     {0xfe, 0xfe, 0xe0, 0xe0, 0xfe, 0xfe, 0xf0, 0xf0}, {0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe} /*w*/
 };
 
 bool SymmetricKey::isWeakDESKey()
 {
     if (size() != 8)
         return false; // dubious
     SecureArray workingCopy(8);
     // clear parity bits
     for (uint i = 0; i < 8; i++)
         workingCopy[i] = (data()[i]) & 0xfe;
 
     for (auto n : desWeakKeyTable) {
         if (memcmp(workingCopy.data(), n, 8) == 0)
             return true;
     }
     return false;
 }
 
 //----------------------------------------------------------------------------
 // InitializationVector
 //----------------------------------------------------------------------------
 InitializationVector::InitializationVector()
 {
 }
 
 InitializationVector::InitializationVector(int size)
 {
     set(Random::randomArray(size));
 }
 
 InitializationVector::InitializationVector(const SecureArray &a)
 {
     set(a);
 }
 
 InitializationVector::InitializationVector(const QByteArray &a)
 {
     set(SecureArray(a));
 }
 
 //----------------------------------------------------------------------------
 // AuthTag
 //----------------------------------------------------------------------------
 AuthTag::AuthTag()
 {
 }
 
 AuthTag::AuthTag(int size)
 {
     resize(size);
 }
 
 AuthTag::AuthTag(const SecureArray &a)
 {
     set(a);
 }
 
 AuthTag::AuthTag(const QByteArray &a)
 {
     set(SecureArray(a));
 }
 
 //----------------------------------------------------------------------------
 // Event
 //----------------------------------------------------------------------------
 class Event::Private : public QSharedData
 {
 public:
     Type          type;
     Source        source;
     PasswordStyle style;
     KeyStoreInfo  ksi;
     KeyStoreEntry kse;
     QString       fname;
     void         *ptr;
 };
 
 Event::Event()
 {
 }
 
 Event::Event(const Event &from)
     : d(from.d)
 {
 }
 
 Event::~Event()
 {
 }
 
 Event &Event::operator=(const Event &from)
 {
     d = from.d;
     return *this;
 }
 
 bool Event::isNull() const
 {
     return (d ? false : true);
 }
 
 Event::Type Event::type() const
 {
     return d->type;
 }
 
 Event::Source Event::source() const
 {
     return d->source;
 }
 
 Event::PasswordStyle Event::passwordStyle() const
 {
     return d->style;
 }
 
 KeyStoreInfo Event::keyStoreInfo() const
 {
     return d->ksi;
 }
 
 KeyStoreEntry Event::keyStoreEntry() const
 {
     return d->kse;
 }
 
 QString Event::fileName() const
 {
     return d->fname;
 }
 
 void *Event::ptr() const
 {
     return d->ptr;
 }
 
 void Event::setPasswordKeyStore(PasswordStyle        pstyle,
                                 const KeyStoreInfo  &keyStoreInfo,
                                 const KeyStoreEntry &keyStoreEntry,
                                 void                *ptr)
 {
     if (!d)
         d = new Private;
     d->type   = Password;
     d->source = KeyStore;
     d->style  = pstyle;
     d->ksi    = keyStoreInfo;
     d->kse    = keyStoreEntry;
     d->fname  = QString();
     d->ptr    = ptr;
 }
 
 void Event::setPasswordData(PasswordStyle pstyle, const QString &fileName, void *ptr)
 {
     if (!d)
         d = new Private;
     d->type   = Password;
     d->source = Data;
     d->style  = pstyle;
     d->ksi    = KeyStoreInfo();
     d->kse    = KeyStoreEntry();
     d->fname  = fileName;
     d->ptr    = ptr;
 }
 
 void Event::setToken(const KeyStoreInfo &keyStoreInfo, const KeyStoreEntry &keyStoreEntry, void *ptr)
 {
     if (!d)
         d = new Private;
     d->type   = Token;
     d->source = KeyStore;
     d->style  = StylePassword;
     d->ksi    = keyStoreInfo;
     d->kse    = keyStoreEntry;
     d->fname  = QString();
     d->ptr    = ptr;
 }
 
 //----------------------------------------------------------------------------
 // EventGlobal
 //----------------------------------------------------------------------------
 class HandlerBase : public QObject
 {
     Q_OBJECT
 public:
     HandlerBase(QObject *parent = nullptr)
         : QObject(parent)
     {
     }
 
 protected Q_SLOTS:
     virtual void ask(int id, const QCA::Event &e) = 0;
 };
 
 class AskerBase : public QObject
 {
     Q_OBJECT
 public:
     AskerBase(QObject *parent = nullptr)
         : QObject(parent)
     {
     }
 
     virtual void set_accepted(const SecureArray &password) = 0;
     virtual void set_rejected()                            = 0;
 };
 
 static void handler_add(HandlerBase *h, int pos = -1);
 static void handler_remove(HandlerBase *h);
 static void handler_accept(HandlerBase *h, int id, const SecureArray &password);
 static void handler_reject(HandlerBase *h, int id);
 static bool asker_ask(AskerBase *a, const Event &e);
 static void asker_cancel(AskerBase *a);
 
 Q_GLOBAL_STATIC(QMutex, g_event_mutex)
 
 class EventGlobal;
 static EventGlobal *g_event = nullptr;
 
 class EventGlobal
 {
 public:
     class HandlerItem
     {
     public:
         HandlerBase *h;
         QList<int>   ids;
     };
 
     class AskerItem
     {
     public:
         AskerBase *a;
         int        id;
         Event      event;
         int        handler_pos;
     };
 
     QList<HandlerItem> handlers;
     QList<AskerItem>   askers;
 
     int next_id;
 
     EventGlobal()
     {
         qRegisterMetaType<Event>("QCA::Event");
         qRegisterMetaType<SecureArray>("QCA::SecureArray");
         next_id = 0;
     }
 
     int findHandlerItem(HandlerBase *h)
     {
         for (int n = 0; n < handlers.count(); ++n) {
             if (handlers[n].h == h)
                 return n;
         }
         return -1;
     }
 
     int findAskerItem(AskerBase *a)
     {
         for (int n = 0; n < askers.count(); ++n) {
             if (askers[n].a == a)
                 return n;
         }
         return -1;
     }
 
     int findAskerItemById(int id)
     {
         for (int n = 0; n < askers.count(); ++n) {
             if (askers[n].id == id)
                 return n;
         }
         return -1;
     }
 
     void ask(int asker_at)
     {
         AskerItem &i = askers[asker_at];
 
         g_event->handlers[i.handler_pos].ids += i.id;
         QMetaObject::invokeMethod(
             handlers[i.handler_pos].h, "ask", Qt::QueuedConnection, Q_ARG(int, i.id), Q_ARG(QCA::Event, i.event));
     }
 
     void reject(int asker_at)
     {
         AskerItem &i = askers[asker_at];
 
         // look for the next usable handler
         int pos = -1;
         for (int n = i.handler_pos + 1; n < g_event->handlers.count(); ++n) {
             // handler and asker can't be in the same thread
             // Q_ASSERT(g_event->handlers[n].h->thread() != i.a->thread());
             // if(g_event->handlers[n].h->thread() != i.a->thread())
             //{
             pos = n;
             break;
             //}
         }
 
         // if there is one, try it
         if (pos != -1) {
             i.handler_pos = pos;
             ask(asker_at);
         }
         // if not, send official reject
         else {
             AskerBase *asker = i.a;
             askers.removeAt(asker_at);
 
             asker->set_rejected();
         }
     }
 };
 
 void handler_add(HandlerBase *h, int pos)
 {
     QMutexLocker locker(g_event_mutex());
     if (!g_event)
         g_event = new EventGlobal;
 
     EventGlobal::HandlerItem i;
     i.h = h;
 
     if (pos != -1) {
         g_event->handlers.insert(pos, i);
 
         // adjust handler positions
         for (int n = 0; n < g_event->askers.count(); ++n) {
             if (g_event->askers[n].handler_pos >= pos)
                 g_event->askers[n].handler_pos++;
         }
     } else
         g_event->handlers += i;
 }
 
 void handler_remove(HandlerBase *h)
 {
     QMutexLocker locker(g_event_mutex());
     Q_ASSERT(g_event);
     if (!g_event)
         return;
     int at = g_event->findHandlerItem(h);
     Q_ASSERT(at != -1);
     if (at == -1)
         return;
 
     const QList<int> ids = g_event->handlers[at].ids;
     g_event->handlers.removeAt(at);
 
     // adjust handler positions within askers
     for (int n = 0; n < g_event->askers.count(); ++n) {
         if (g_event->askers[n].handler_pos >= at)
             g_event->askers[n].handler_pos--;
     }
 
     // reject all askers
     foreach (int id, ids) {
         int asker_at = g_event->findAskerItemById(id);
         Q_ASSERT(asker_at != -1);
 
         g_event->reject(asker_at);
     }
 
     if (g_event->handlers.isEmpty()) {
         delete g_event;
         g_event = nullptr;
     }
 }
 
 void handler_accept(HandlerBase *h, int id, const SecureArray &password)
 {
     QMutexLocker locker(g_event_mutex());
     Q_ASSERT(g_event);
     if (!g_event)
         return;
     int at = g_event->findHandlerItem(h);
     Q_ASSERT(at != -1);
     if (at == -1)
         return;
     int asker_at = g_event->findAskerItemById(id);
     Q_ASSERT(asker_at != -1);
     if (asker_at == -1)
         return;
 
     g_event->handlers[at].ids.removeAll(g_event->askers[asker_at].id);
 
     AskerBase *asker = g_event->askers[asker_at].a;
     asker->set_accepted(password);
 }
 
 void handler_reject(HandlerBase *h, int id)
 {
     QMutexLocker locker(g_event_mutex());
     Q_ASSERT(g_event);
     if (!g_event)
         return;
     int at = g_event->findHandlerItem(h);
     Q_ASSERT(at != -1);
     if (at == -1)
         return;
     int asker_at = g_event->findAskerItemById(id);
     Q_ASSERT(asker_at != -1);
     if (asker_at == -1)
         return;
 
     g_event->handlers[at].ids.removeAll(g_event->askers[asker_at].id);
 
     g_event->reject(asker_at);
 }
 
 bool asker_ask(AskerBase *a, const Event &e)
 {
     QMutexLocker locker(g_event_mutex());
     if (!g_event)
         return false;
 
     int pos = -1;
     for (int n = 0; n < g_event->handlers.count(); ++n) {
         // handler and asker can't be in the same thread
         // Q_ASSERT(g_event->handlers[n].h->thread() != a->thread());
         // if(g_event->handlers[n].h->thread() != a->thread())
         //{
         pos = n;
         break;
         //}
     }
     if (pos == -1)
         return false;
 
     EventGlobal::AskerItem i;
     i.a           = a;
     i.id          = g_event->next_id++;
     i.event       = e;
     i.handler_pos = pos;
     g_event->askers += i;
     const int asker_at = g_event->askers.count() - 1;
 
     g_event->ask(asker_at);
     return true;
 }
 
 void asker_cancel(AskerBase *a)
 {
     QMutexLocker locker(g_event_mutex());
     if (!g_event)
         return;
     int at = g_event->findAskerItem(a);
     if (at == -1)
         return;
 
     for (int n = 0; n < g_event->handlers.count(); ++n)
         g_event->handlers[n].ids.removeAll(g_event->askers[at].id);
 
     g_event->askers.removeAt(at);
 }
 
 //----------------------------------------------------------------------------
 // EventHandler
 //----------------------------------------------------------------------------
 class EventHandler::Private : public HandlerBase
 {
     Q_OBJECT
 public:
     EventHandler *q;
     bool          started;
     QList<int>    activeIds;
 
     Private(EventHandler *_q)
         : HandlerBase(_q)
         , q(_q)
     {
         started = false;
     }
 
 public Q_SLOTS:
     void ask(int id, const QCA::Event &e) override
     {
         activeIds += id;
         emit q->eventReady(id, e);
     }
 };
 
 EventHandler::EventHandler(QObject *parent)
     : QObject(parent)
 {
     d = new Private(this);
 }
 
 EventHandler::~EventHandler()
 {
     if (d->started) {
         foreach (int id, d->activeIds)
             handler_reject(d, id);
 
         handler_remove(d);
     }
 
     delete d;
 }
 
 void EventHandler::start()
 {
     d->started = true;
     handler_add(d);
 }
 
 void EventHandler::submitPassword(int id, const SecureArray &password)
 {
     if (!d->activeIds.contains(id))
         return;
 
     d->activeIds.removeAll(id);
     handler_accept(d, id, password);
 }
 
 void EventHandler::tokenOkay(int id)
 {
     if (!d->activeIds.contains(id))
         return;
 
     d->activeIds.removeAll(id);
     handler_accept(d, id, SecureArray());
 }
 
 void EventHandler::reject(int id)
 {
     if (!d->activeIds.contains(id))
         return;
 
     d->activeIds.removeAll(id);
     handler_reject(d, id);
 }
 
 //----------------------------------------------------------------------------
 // PasswordAsker
 //----------------------------------------------------------------------------
 class AskerPrivate : public AskerBase
 {
     Q_OBJECT
 public:
     enum Type
     {
         Password,
         Token
     };
 
     Type           type;
     PasswordAsker *passwordAsker;
     TokenAsker    *tokenAsker;
 
     QMutex         m;
     QWaitCondition w;
 
     bool        accepted;
     SecureArray password;
     bool        waiting;
     bool        done;
 
     AskerPrivate(PasswordAsker *parent)
         : AskerBase(parent)
     {
         passwordAsker = parent;
         tokenAsker    = nullptr;
         type          = Password;
         accepted      = false;
         waiting       = false;
         done          = true;
     }
 
     AskerPrivate(TokenAsker *parent)
         : AskerBase(parent)
     {
         passwordAsker = nullptr;
         tokenAsker    = parent;
         type          = Token;
         accepted      = false;
         waiting       = false;
         done          = true;
     }
 
     void ask(const Event &e)
     {
         accepted = false;
         waiting  = false;
         done     = false;
         password.clear();
 
         if (!asker_ask(this, e)) {
             done = true;
             QMetaObject::invokeMethod(this, "emitResponseReady", Qt::QueuedConnection);
         }
     }
 
     void cancel()
     {
         if (!done)
             asker_cancel(this);
     }
 
     void set_accepted(const SecureArray &_password) override
     {
         QMutexLocker locker(&m);
         accepted = true;
         password = _password;
         done     = true;
         if (waiting)
             w.wakeOne();
         else
             QMetaObject::invokeMethod(this, "emitResponseReady", Qt::QueuedConnection);
     }
 
     void set_rejected() override
     {
         QMutexLocker locker(&m);
         done = true;
         if (waiting)
             w.wakeOne();
         else
             QMetaObject::invokeMethod(this, "emitResponseReady", Qt::QueuedConnection);
     }
 
     void waitForResponse()
     {
         QMutexLocker locker(&m);
         if (done)
             return;
         waiting = true;
         w.wait(&m);
         waiting = false;
     }
 
 public Q_SLOTS:
     virtual void emitResponseReady() = 0;
 };
 
 class PasswordAsker::Private : public AskerPrivate
 {
     Q_OBJECT
 public:
     Private(PasswordAsker *_q)
         : AskerPrivate(_q)
     {
     }
 
     void emitResponseReady() override
     {
         emit passwordAsker->responseReady();
     }
 };
 
 PasswordAsker::PasswordAsker(QObject *parent)
     : QObject(parent)
 {
     d = new Private(this);
 }
 
 PasswordAsker::~PasswordAsker()
 {
     delete d;
 }
 
 void PasswordAsker::ask(Event::PasswordStyle pstyle,
                         const KeyStoreInfo  &keyStoreInfo,
                         const KeyStoreEntry &keyStoreEntry,
                         void                *ptr)
 {
     Event e;
     e.setPasswordKeyStore(pstyle, keyStoreInfo, keyStoreEntry, ptr);
     d->ask(e);
 }
 
 void PasswordAsker::ask(Event::PasswordStyle pstyle, const QString &fileName, void *ptr)
 {
     Event e;
     e.setPasswordData(pstyle, fileName, ptr);
     d->ask(e);
 }
 
 void PasswordAsker::cancel()
 {
     d->cancel();
 }
 
 void PasswordAsker::waitForResponse()
 {
     d->waitForResponse();
 }
 
 bool PasswordAsker::accepted() const
 {
     return d->accepted;
 }
 
 SecureArray PasswordAsker::password() const
 {
     return d->password;
 }
 
 //----------------------------------------------------------------------------
 // TokenAsker
 //----------------------------------------------------------------------------
 class TokenAsker::Private : public AskerPrivate
 {
     Q_OBJECT
 public:
     Private(TokenAsker *_q)
         : AskerPrivate(_q)
     {
     }
 
     void emitResponseReady() override
     {
         emit tokenAsker->responseReady();
     }
 };
 
 TokenAsker::TokenAsker(QObject *parent)
     : QObject(parent)
 {
     d = new Private(this);
 }
 
 TokenAsker::~TokenAsker()
 {
     delete d;
 }
 
 void TokenAsker::ask(const KeyStoreInfo &keyStoreInfo, const KeyStoreEntry &keyStoreEntry, void *ptr)
 {
     Event e;
     e.setToken(keyStoreInfo, keyStoreEntry, ptr);
     d->ask(e);
 }
 
 void TokenAsker::cancel()
 {
     d->cancel();
 }
 
 void TokenAsker::waitForResponse()
 {
     d->waitForResponse();
 }
 
 bool TokenAsker::accepted() const
 {
     return d->accepted;
 }
 
 }
 
 #include "qca_core.moc"