From 4c565dd7dd78340a393ccbf4bc3bed9f6ce360f2 Mon Sep 17 00:00:00 2001 From: Melvin Keskin Date: Tue, 19 Apr 2022 20:05:16 +0200 Subject: Add QXmppTrustManager as base of trust managers such as QXmppAtmManager --- src/client/QXmppTrustManager.cpp | 282 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 282 insertions(+) create mode 100644 src/client/QXmppTrustManager.cpp (limited to 'src/client/QXmppTrustManager.cpp') diff --git a/src/client/QXmppTrustManager.cpp b/src/client/QXmppTrustManager.cpp new file mode 100644 index 00000000..094ed2f2 --- /dev/null +++ b/src/client/QXmppTrustManager.cpp @@ -0,0 +1,282 @@ +// SPDX-FileCopyrightText: 2022 Melvin Keskin +// +// SPDX-License-Identifier: LGPL-2.1-or-later + +#include "QXmppTrustManager.h" + +#include "QXmppFutureUtils_p.h" + +using namespace QXmpp::Private; + +/// +/// \class QXmppTrustManager +/// +/// \brief The QXmppTrustManager manages end-to-end encryption trust decisions. +/// +/// \warning THIS API IS NOT FINALIZED YET! +/// +/// \ingroup Managers +/// +/// \since QXmpp 1.5 +/// + +/// +/// Constructs a trust manager. +/// +/// \param trustStorage trust storage implementation +/// +QXmppTrustManager::QXmppTrustManager(QXmppTrustStorage *trustStorage) + : m_trustStorage(trustStorage) +{ +} + +QXmppTrustManager::~QXmppTrustManager() = default; + +/// +/// Sets the security policy for an encryption protocol. +/// +/// \param encryption encryption protocol namespace +/// \param securityPolicy security policy being applied +/// +QFuture QXmppTrustManager::setSecurityPolicy(const QString &encryption, QXmppTrustStorage::SecurityPolicy securityPolicy) +{ + return m_trustStorage->setSecurityPolicy(encryption, securityPolicy); +} + +/// +/// Resets the security policy for an encryption protocol. +/// +/// \param encryption encryption protocol namespace +/// +QFuture QXmppTrustManager::resetSecurityPolicy(const QString &encryption) +{ + return m_trustStorage->resetSecurityPolicy(encryption); +} + +/// +/// Returns the security policy for an encryption protocol. +/// +/// \param encryption encryption protocol namespace +/// +/// \return the set security policy +/// +QFuture QXmppTrustManager::securityPolicy(const QString &encryption) +{ + return m_trustStorage->securityPolicy(encryption); +} + +/// +/// Sets the own key (i.e., the key used by this client instance) for an +/// encryption protocol. +/// +/// \param encryption encryption protocol namespace +/// \param keyId ID of the key +/// +QFuture QXmppTrustManager::setOwnKey(const QString &encryption, const QByteArray &keyId) +{ + return m_trustStorage->setOwnKey(encryption, keyId); +} + +/// +/// Resets the own key (i.e., the key used by this client instance) for an +/// encryption protocol. +/// +/// \param encryption encryption protocol namespace +/// +QFuture QXmppTrustManager::resetOwnKey(const QString &encryption) +{ + return m_trustStorage->resetOwnKey(encryption); +} + +/// +/// Returns the own key (i.e., the key used by this client instance) for an +/// encryption protocol. +/// +/// \param encryption encryption protocol namespace +/// +/// \return the ID of the own key +/// +QFuture QXmppTrustManager::ownKey(const QString &encryption) +{ + return m_trustStorage->ownKey(encryption); +} + +/// +/// Adds keys. +/// +/// \param encryption encryption protocol namespace +/// \param keyOwnerJid key owner's bare JID +/// \param keyIds IDs of the keys +/// \param trustLevel trust level of the keys +/// +QFuture QXmppTrustManager::addKeys(const QString &encryption, const QString &keyOwnerJid, const QList &keyIds, QXmppTrustStorage::TrustLevel trustLevel) +{ + return m_trustStorage->addKeys(encryption, keyOwnerJid, keyIds, trustLevel); +} + +/// +/// Removes keys. +/// +/// \param encryption encryption protocol namespace +/// \param keyIds IDs of the keys +/// +QFuture QXmppTrustManager::removeKeys(const QString &encryption, const QList &keyIds) +{ + return m_trustStorage->removeKeys(encryption, keyIds); +} + +/// +/// Removes all keys of a key owner. +/// +/// \param encryption encryption protocol namespace +/// \param keyOwnerJid key owner's bare JID +/// +QFuture QXmppTrustManager::removeKeys(const QString &encryption, const QString &keyOwnerJid) +{ + return m_trustStorage->removeKeys(encryption, keyOwnerJid); +} + +/// +/// Removes all keys for encryption. +/// +/// \param encryption encryption protocol namespace +/// +QFuture QXmppTrustManager::removeKeys(const QString &encryption) +{ + return m_trustStorage->removeKeys(encryption); +} + +/// +/// Returns the JIDs of all key owners mapped to the IDs of their keys with +/// specific trust levels. +/// +/// If no trust levels are passed, all keys for encryption are returned. +/// +/// \param encryption encryption protocol namespace +/// \param trustLevels trust levels of the keys +/// +/// \return the key owner JIDs mapped to their keys with specific trust levels +/// +QFuture>> QXmppTrustManager::keys(const QString &encryption, QXmppTrustStorage::TrustLevels trustLevels) +{ + return m_trustStorage->keys(encryption, trustLevels); +} + +/// +/// Returns the IDs of keys mapped to their trust levels for specific key +/// owners. +/// +/// If no trust levels are passed, all keys for encryption and keyOwnerJids are +/// returned. +/// +/// \param encryption encryption protocol namespace +/// \param keyOwnerJids key owners' bare JIDs +/// \param trustLevels trust levels of the keys +/// +/// \return the key IDs mapped to their trust levels for specific key owners +/// +QFuture>> QXmppTrustManager::keys(const QString &encryption, const QList &keyOwnerJids, QXmppTrustStorage::TrustLevels trustLevels) +{ + return m_trustStorage->keys(encryption, keyOwnerJids, trustLevels); +} + +/// +/// Returns whether at least one key of a key owner with a specific trust level +/// is stored. +/// +/// \param encryption encryption protocol namespace +/// \param keyOwnerJid key owner's bare JID +/// \param trustLevels possible trust levels of the key +/// +/// \return whether a key of the key owner with a passed trust level is stored +/// +QFuture QXmppTrustManager::hasKey(const QString &encryption, const QString &keyOwnerJid, QXmppTrustStorage::TrustLevels trustLevels) +{ + return m_trustStorage->hasKey(encryption, keyOwnerJid, trustLevels); +} + +/// +/// Sets the trust level of keys. +/// +/// If a key is not stored, it is added to the storage. +/// +/// \param encryption encryption protocol namespace +/// \param keyIds key owners' bare JIDs mapped to the IDs of their keys +/// \param trustLevel trust level being set +/// +QFuture QXmppTrustManager::setTrustLevel(const QString &encryption, const QMultiHash &keyIds, QXmppTrustStorage::TrustLevel trustLevel) +{ + QFutureInterface interface(QFutureInterfaceBase::Started); + + auto future = m_trustStorage->setTrustLevel(encryption, keyIds, trustLevel); + await(future, this, [=](QHash> modifiedKeys) mutable { + emit trustLevelsChanged(modifiedKeys); + interface.reportFinished(); + }); + + return interface.future(); +} + +/// +/// Sets the trust level of keys specified by their key owner and trust level. +/// +/// \param encryption encryption protocol namespace +/// \param keyOwnerJids key owners' bare JIDs +/// \param oldTrustLevel trust level being changed +/// \param newTrustLevel trust level being set +/// +QFuture QXmppTrustManager::setTrustLevel(const QString &encryption, const QList &keyOwnerJids, QXmppTrustStorage::TrustLevel oldTrustLevel, QXmppTrustStorage::TrustLevel newTrustLevel) +{ + QFutureInterface interface(QFutureInterfaceBase::Started); + + auto future = m_trustStorage->setTrustLevel(encryption, keyOwnerJids, oldTrustLevel, newTrustLevel); + await(future, this, [=](QHash> modifiedKeys) mutable { + emit trustLevelsChanged(modifiedKeys); + interface.reportFinished(); + }); + + return interface.future(); +} + +/// +/// Returns the trust level of a key. +/// +/// If the key is not stored, the trust in that key is undecided. +/// +/// \param encryption encryption protocol namespace +/// \param keyOwnerJid key owner's bare JID +/// \param keyId ID of the key +/// +/// \return the key's trust level +/// +QFuture QXmppTrustManager::trustLevel(const QString &encryption, const QString &keyOwnerJid, const QByteArray &keyId) +{ + return m_trustStorage->trustLevel(encryption, keyOwnerJid, keyId); +} + +/// +/// Resets all data for encryption. +/// +/// \param encryption encryption protocol namespace +/// +QFuture QXmppTrustManager::resetAll(const QString &encryption) +{ + return m_trustStorage->resetAll(encryption); +} + +/// \cond +bool QXmppTrustManager::handleStanza(const QDomElement &stanza) +{ + return false; +} +/// \endcond + +/// +/// \fn QXmppTrustManager::trustLevelsChanged(const QHash> &modifiedKeys) +/// +/// Emitted when the trust levels of keys changed because \c setTrustLevel() +/// added a new key or modified an existing one. +/// +/// \param modifiedKeys key owners' bare JIDs mapped to their modified keys for +/// specific encryption protocol namespaces +/// -- cgit v1.2.3