Update to OMEMO 0.8, TM 0.6 and ATM 0.4

* OMEMO has namespace 'urn:xmpp:omemo:2' and uses SCE 0.4 now
* TM has namespace 'urn:xmpp:tm:1' and uses Base64 for key identifiers
* ATM uses Base64 for key identifiers

13 files changed, 103 insertions, 101 deletions

diff --git a/src/base/QXmppConstants.cpp b/src/base/QXmppConstants.cpp
index c6ae77de..0f06a3da 100644
--- a/src/base/QXmppConstants.cpp
+++ b/src/base/QXmppConstants.cpp
@@ -175,7 +175,7 @@ const char* ns_eme = "urn:xmpp:eme:0";
 const char* ns_spoiler = "urn:xmpp:spoiler:0";
 // XEP-0384: OMEMO Encryption
 const char* ns_omemo = "eu.siacs.conversations.axolotl";
-const char* ns_omemo_1 = "urn:xmpp:omemo:1";
+const char* ns_omemo_2 = "urn:xmpp:omemo:2";
 // XEP-0405: Mediated Information eXchange (MIX): Participant Server Requirements
 const char* ns_mix_pam = "urn:xmpp:mix:pam:1";
 const char* ns_mix_roster = "urn:xmpp:mix:roster:0";
@@ -185,6 +185,6 @@ const char* ns_mix_misc = "urn:xmpp:mix:misc:0";
 // XEP-0428: Fallback Indication
 const char* ns_fallback_indication = "urn:xmpp:fallback:0";
 // XEP-0434: Trust Messages (TM)
-const char* ns_tm = "urn:xmpp:tm:0";
+const char* ns_tm = "urn:xmpp:tm:1";
 // XEP-0450: Automatic Trust Management (ATM)
 const char* ns_atm = "urn:xmpp:atm:1";
diff --git a/src/base/QXmppConstants_p.h b/src/base/QXmppConstants_p.h
index 2b9e70d6..47dbdd87 100644
--- a/src/base/QXmppConstants_p.h
+++ b/src/base/QXmppConstants_p.h
@@ -187,7 +187,7 @@ extern const char* ns_eme;
 extern const char* ns_spoiler;
 // XEP-0384: OMEMO Encryption
 extern const char* ns_omemo;
-extern const char* ns_omemo_1;
+extern const char* ns_omemo_2;
 // XEP-0405: Mediated Information eXchange (MIX): Participant Server Requirements
 extern const char* ns_mix_pam;
 extern const char* ns_mix_roster;
diff --git a/src/base/QXmppMessage.cpp b/src/base/QXmppMessage.cpp
index c6313c65..c5a30a46 100644
--- a/src/base/QXmppMessage.cpp
+++ b/src/base/QXmppMessage.cpp
@@ -5,6 +5,7 @@
  *  Manjeet Dahiya
  *  Jeremy Lainé
  *  Linus Jahn
+ *  Melvin Keskin
  *
  * Source:
  *  https://github.com/qxmpp-project/qxmpp
@@ -108,7 +109,7 @@ public:
     QString thread;
     QString parentThread;
     QXmppMessage::Type type;
-    QString senderKey;
+    QByteArray senderKey;
 
     // XEP-0066: Out of Band Data
     QString outOfBandUrl;
@@ -339,7 +340,7 @@ void QXmppMessage::setParentThread(const QString &parent)
 ///
 /// \since QXmpp 1.5
 ///
-QString QXmppMessage::senderKey() const
+QByteArray QXmppMessage::senderKey() const
 {
     return d->senderKey;
 }
@@ -358,7 +359,7 @@ QString QXmppMessage::senderKey() const
 ///
 /// \since QXmpp 1.5
 ///
-void QXmppMessage::setSenderKey(const QString &keyId)
+void QXmppMessage::setSenderKey(const QByteArray &keyId)
 {
     d->senderKey = keyId;
 }
diff --git a/src/base/QXmppMessage.h b/src/base/QXmppMessage.h
index 242420ff..ee1ecdca 100644
--- a/src/base/QXmppMessage.h
+++ b/src/base/QXmppMessage.h
@@ -5,6 +5,7 @@
  *  Manjeet Dahiya
  *  Jeremy Lainé
  *  Linus Jahn
+ *  Melvin Keskin
  *
  * Source:
  *  https://github.com/qxmpp-project/qxmpp
@@ -136,8 +137,8 @@ public:
     QXmppMessage::Type type() const;
     void setType(QXmppMessage::Type);
 
-    QString senderKey() const;
-    void setSenderKey(const QString &keyId);
+    QByteArray senderKey() const;
+    void setSenderKey(const QByteArray &keyId);
 
     // XEP-0066: Out of Band Data
     QString outOfBandUrl() const;
diff --git a/src/base/QXmppOmemoData.cpp b/src/base/QXmppOmemoData.cpp
index fbcf8261..46932f03 100644
--- a/src/base/QXmppOmemoData.cpp
+++ b/src/base/QXmppOmemoData.cpp
@@ -163,7 +163,7 @@ void QXmppOmemoDeviceElement::toXml(QXmlStreamWriter *writer) const
 bool QXmppOmemoDeviceElement::isOmemoDeviceElement(const QDomElement &element)
 {
     return element.tagName() == QStringLiteral("device") &&
-        element.namespaceURI() == ns_omemo_1;
+        element.namespaceURI() == ns_omemo_2;
 }
 
 ///
@@ -213,7 +213,7 @@ void QXmppOmemoDeviceList::parse(const QDomElement &element)
 void QXmppOmemoDeviceList::toXml(QXmlStreamWriter *writer) const
 {
     writer->writeStartElement("devices");
-    writer->writeDefaultNamespace(ns_omemo_1);
+    writer->writeDefaultNamespace(ns_omemo_2);
 
     for (const auto &device : *this) {
         device.toXml(writer);
@@ -233,7 +233,7 @@ void QXmppOmemoDeviceList::toXml(QXmlStreamWriter *writer) const
 bool QXmppOmemoDeviceList::isOmemoDeviceList(const QDomElement &element)
 {
     return element.tagName() == QStringLiteral("devices") &&
-        element.namespaceURI() == ns_omemo_1;
+        element.namespaceURI() == ns_omemo_2;
 }
 
 ///
@@ -427,7 +427,7 @@ void QXmppOmemoDeviceBundle::parse(const QDomElement &element)
 void QXmppOmemoDeviceBundle::toXml(QXmlStreamWriter *writer) const
 {
     writer->writeStartElement(QStringLiteral("bundle"));
-    writer->writeDefaultNamespace(ns_omemo_1);
+    writer->writeDefaultNamespace(ns_omemo_2);
 
     writer->writeStartElement(QStringLiteral("ik"));
     writer->writeCharacters(publicIdentityKey().toBase64());
@@ -465,7 +465,7 @@ void QXmppOmemoDeviceBundle::toXml(QXmlStreamWriter *writer) const
 bool QXmppOmemoDeviceBundle::isOmemoDeviceBundle(const QDomElement &element)
 {
     return element.tagName() == QStringLiteral("bundle") &&
-        element.namespaceURI() == ns_omemo_1;
+        element.namespaceURI() == ns_omemo_2;
 }
 
 ///
@@ -617,7 +617,7 @@ void QXmppOmemoEnvelope::toXml(QXmlStreamWriter *writer) const
 bool QXmppOmemoEnvelope::isOmemoEnvelope(const QDomElement &element)
 {
     return element.tagName() == QStringLiteral("key") &&
-        element.namespaceURI() == ns_omemo_1;
+        element.namespaceURI() == ns_omemo_2;
 }
 
 ///
@@ -767,7 +767,7 @@ void QXmppOmemoElement::parse(const QDomElement &element)
 void QXmppOmemoElement::toXml(QXmlStreamWriter *writer) const
 {
     writer->writeStartElement("encrypted");
-    writer->writeAttribute("xmlns", ns_omemo_1);
+    writer->writeAttribute("xmlns", ns_omemo_2);
 
     writer->writeStartElement("header");
     writer->writeAttribute("sid", QString::number(d->senderDeviceId));
@@ -803,5 +803,5 @@ void QXmppOmemoElement::toXml(QXmlStreamWriter *writer) const
 bool QXmppOmemoElement::isOmemoElement(const QDomElement &element)
 {
     return element.tagName() == QStringLiteral("encrypted") &&
-        element.namespaceURI() == ns_omemo_1;
+        element.namespaceURI() == ns_omemo_2;
 }
diff --git a/src/base/QXmppTrustMessageKeyOwner.h b/src/base/QXmppTrustMessageKeyOwner.h
index 84a0d610..9c351b3c 100644
--- a/src/base/QXmppTrustMessageKeyOwner.h
+++ b/src/base/QXmppTrustMessageKeyOwner.h
@@ -44,11 +44,11 @@ public:
     QString jid() const;
     void setJid(const QString &jid);
 
-    QList<QString> trustedKeys() const;
-    void setTrustedKeys(const QList<QString> &keyIds);
+    QList<QByteArray> trustedKeys() const;
+    void setTrustedKeys(const QList<QByteArray> &keyIds);
 
-    QList<QString> distrustedKeys() const;
-    void setDistrustedKeys(const QList<QString> &keyIds);
+    QList<QByteArray> distrustedKeys() const;
+    void setDistrustedKeys(const QList<QByteArray> &keyIds);
 
     /// \cond
     void parse(const QDomElement &element);
diff --git a/src/base/QXmppTrustMessages.cpp b/src/base/QXmppTrustMessages.cpp
index 621fb5dd..ce76ab26 100644
--- a/src/base/QXmppTrustMessages.cpp
+++ b/src/base/QXmppTrustMessages.cpp
@@ -200,8 +200,8 @@ class QXmppTrustMessageKeyOwnerPrivate : public QSharedData
 {
 public:
     QString jid;
-    QList<QString> trustedKeys;
-    QList<QString> distrustedKeys;
+    QList<QByteArray> trustedKeys;
+    QList<QByteArray> distrustedKeys;
 };
 
 ///
@@ -255,7 +255,7 @@ void QXmppTrustMessageKeyOwner::setJid(const QString &jid)
 ///
 /// \return the IDs of trusted keys
 ///
-QList<QString> QXmppTrustMessageKeyOwner::trustedKeys() const
+QList<QByteArray> QXmppTrustMessageKeyOwner::trustedKeys() const
 {
     return d->trustedKeys;
 }
@@ -265,7 +265,7 @@ QList<QString> QXmppTrustMessageKeyOwner::trustedKeys() const
 ///
 /// \param keyIds IDs of trusted keys
 ///
-void QXmppTrustMessageKeyOwner::setTrustedKeys(const QList<QString> &keyIds)
+void QXmppTrustMessageKeyOwner::setTrustedKeys(const QList<QByteArray> &keyIds)
 {
     d->trustedKeys = keyIds;
 }
@@ -275,7 +275,7 @@ void QXmppTrustMessageKeyOwner::setTrustedKeys(const QList<QString> &keyIds)
 ///
 /// \return the IDs of distrusted keys
 ///
-QList<QString> QXmppTrustMessageKeyOwner::distrustedKeys() const
+QList<QByteArray> QXmppTrustMessageKeyOwner::distrustedKeys() const
 {
     return d->distrustedKeys;
 }
@@ -285,7 +285,7 @@ QList<QString> QXmppTrustMessageKeyOwner::distrustedKeys() const
 ///
 /// \param keyIds IDs of distrusted keys
 ///
-void QXmppTrustMessageKeyOwner::setDistrustedKeys(const QList<QString> &keyIds)
+void QXmppTrustMessageKeyOwner::setDistrustedKeys(const QList<QByteArray> &keyIds)
 {
     d->distrustedKeys = keyIds;
 }
@@ -298,10 +298,10 @@ void QXmppTrustMessageKeyOwner::parse(const QDomElement &element)
     for (auto childElement = element.firstChildElement();
          !childElement.isNull();
          childElement = childElement.nextSiblingElement()) {
-        if (childElement.tagName() == "trust") {
-            d->trustedKeys.append(childElement.text());
-        } else if (childElement.tagName() == "distrust") {
-            d->distrustedKeys.append(childElement.text());
+        if (const auto tagName = childElement.tagName(); tagName == "trust") {
+            d->trustedKeys.append(QByteArray::fromBase64(childElement.text().toLatin1()));
+        } else if (tagName == "distrust") {
+            d->distrustedKeys.append(QByteArray::fromBase64(childElement.text().toLatin1()));
         }
     }
 }
@@ -312,11 +312,11 @@ void QXmppTrustMessageKeyOwner::toXml(QXmlStreamWriter *writer) const
     writer->writeAttribute("jid", d->jid);
 
     for (const auto &keyIdentifier : d->trustedKeys) {
-        writer->writeTextElement("trust", keyIdentifier);
+        writer->writeTextElement("trust", keyIdentifier.toBase64());
     }
 
     for (const auto &keyIdentifier : d->distrustedKeys) {
-        writer->writeTextElement("distrust", keyIdentifier);
+        writer->writeTextElement("distrust", keyIdentifier.toBase64());
     }
 
     writer->writeEndElement();
diff --git a/src/client/QXmppAtmManager.cpp b/src/client/QXmppAtmManager.cpp
index 04e9ff2a..e0255a9e 100644
--- a/src/client/QXmppAtmManager.cpp
+++ b/src/client/QXmppAtmManager.cpp
@@ -56,7 +56,7 @@ using namespace QXmpp::Private;
 /// Is is recommended to apply TOAKAFA for good security and usability when
 /// using \xep{0384, OMEMO Encryption}:
 /// \code
-/// trustStorage->setSecurityPolicy("urn:xmpp:omemo:1", QXmppTrustStorage::Toakafa);
+/// trustStorage->setSecurityPolicy("urn:xmpp:omemo:2", QXmppTrustStorage::Toakafa);
 /// \endcode
 ///
 /// Afterwards, this manager must be added with the storage:
@@ -107,12 +107,12 @@ QXmppAtmManager::QXmppAtmManager(QXmppTrustStorage *trustStorage)
 /// \param keyIdsForAuthentication IDs of the keys being authenticated
 /// \param keyIdsForDistrusting IDs of the keys being distrusted
 ///
-QFuture<void> QXmppAtmManager::makeTrustDecisions(const QString &encryption, const QString &keyOwnerJid, const QList<QString> &keyIdsForAuthentication, const QList<QString> &keyIdsForDistrusting)
+QFuture<void> QXmppAtmManager::makeTrustDecisions(const QString &encryption, const QString &keyOwnerJid, const QList<QByteArray> &keyIdsForAuthentication, const QList<QByteArray> &keyIdsForDistrusting)
 {
     auto interface = std::make_shared<QFutureInterface<void>>(QFutureInterfaceBase::Started);
 
     auto future = m_trustStorage->keys(encryption, QXmppTrustStorage::Authenticated | QXmppTrustStorage::ManuallyDistrusted);
-    await(future, this, [=](const QHash<QXmppTrustStorage::TrustLevel, QMultiHash<QString, QString>> &&keys) {
+    await(future, this, [=](const QHash<QXmppTrustStorage::TrustLevel, QMultiHash<QString, QByteArray>> &&keys) {
         const auto authenticatedKeys = keys.value(QXmppTrustStorage::Authenticated);
         const auto manuallyDistrustedKeys = keys.value(QXmppTrustStorage::ManuallyDistrusted);
         const auto ownJid = client()->configuration().jidBare();
@@ -123,8 +123,8 @@ QFuture<void> QXmppAtmManager::makeTrustDecisions(const QString &encryption, con
         QXmppTrustMessageKeyOwner keyOwner;
         keyOwner.setJid(keyOwnerJid);
 
-        QList<QString> modifiedAuthenticatedKeys;
-        QList<QString> modifiedManuallyDistrustedKeys;
+        QList<QByteArray> modifiedAuthenticatedKeys;
+        QList<QByteArray> modifiedManuallyDistrustedKeys;
 
         for (const auto &keyId : keyIdsForAuthentication) {
             if (!authenticatedKeys.contains(keyOwnerJid, keyId)) {
@@ -145,8 +145,8 @@ QFuture<void> QXmppAtmManager::makeTrustDecisions(const QString &encryption, con
             keyOwner.setTrustedKeys(modifiedAuthenticatedKeys);
             keyOwner.setDistrustedKeys(modifiedManuallyDistrustedKeys);
 
-            QMultiHash<QString, QString> keysBeingAuthenticated;
-            QMultiHash<QString, QString> keysBeingDistrusted;
+            QMultiHash<QString, QByteArray> keysBeingAuthenticated;
+            QMultiHash<QString, QByteArray> keysBeingDistrusted;
 
             for (const auto &key : std::as_const(modifiedAuthenticatedKeys)) {
                 keysBeingAuthenticated.insert(keyOwnerJid, key);
@@ -299,7 +299,7 @@ void QXmppAtmManager::handleMessageReceived(const QXmppMessage &message)
 /// \param keyIdsForDistrusting key owners' bare JIDs mapped to the IDs of their
 ///        keys being distrusted
 ///
-QFuture<void> QXmppAtmManager::makeTrustDecisions(const QString &encryption, const QMultiHash<QString, QString> &keyIdsForAuthentication, const QMultiHash<QString, QString> &keyIdsForDistrusting)
+QFuture<void> QXmppAtmManager::makeTrustDecisions(const QString &encryption, const QMultiHash<QString, QByteArray> &keyIdsForAuthentication, const QMultiHash<QString, QByteArray> &keyIdsForDistrusting)
 {
     auto interface = std::make_shared<QFutureInterface<void>>(QFutureInterfaceBase::Started);
 
@@ -334,8 +334,8 @@ QFuture<void> QXmppAtmManager::handleMessage(const QXmppMessage &message)
             const auto isSenderKeyAuthenticated = senderKeyTrustLevel == QXmppTrustStorage::Authenticated;
 
             // key owner JIDs mapped to key IDs
-            QMultiHash<QString, QString> keysBeingAuthenticated;
-            QMultiHash<QString, QString> keysBeingDistrusted;
+            QMultiHash<QString, QByteArray> keysBeingAuthenticated;
+            QMultiHash<QString, QByteArray> keysBeingDistrusted;
 
             QList<QXmppTrustMessageKeyOwner> keyOwnersForPostponedTrustDecisions;
 
@@ -400,7 +400,7 @@ QFuture<void> QXmppAtmManager::handleMessage(const QXmppMessage &message)
 /// \param encryption encryption protocol namespace
 /// \param keyIds key owners' bare JIDs mapped to the IDs of their keys
 ///
-QFuture<void> QXmppAtmManager::authenticate(const QString &encryption, const QMultiHash<QString, QString> &keyIds)
+QFuture<void> QXmppAtmManager::authenticate(const QString &encryption, const QMultiHash<QString, QByteArray> &keyIds)
 {
     auto interface = std::make_shared<QFutureInterface<void>>(QFutureInterfaceBase::Started);
 
@@ -435,7 +435,7 @@ QFuture<void> QXmppAtmManager::authenticate(const QString &encryption, const QMu
 /// \param encryption encryption protocol namespace
 /// \param keyIds key owners' bare JIDs mapped to the IDs of their keys
 ///
-QFuture<void> QXmppAtmManager::distrust(const QString &encryption, const QMultiHash<QString, QString> &keyIds)
+QFuture<void> QXmppAtmManager::distrust(const QString &encryption, const QMultiHash<QString, QByteArray> &keyIds)
 {
     auto interface = std::make_shared<QFutureInterface<void>>(QFutureInterfaceBase::Started);
 
@@ -476,12 +476,12 @@ QFuture<void> QXmppAtmManager::distrustAutomaticallyTrustedKeys(const QString &e
 /// \param encryption encryption protocol namespace
 /// \param senderKeyIds IDs of the keys that were used by the senders
 ///
-QFuture<void> QXmppAtmManager::makePostponedTrustDecisions(const QString &encryption, const QList<QString> &senderKeyIds)
+QFuture<void> QXmppAtmManager::makePostponedTrustDecisions(const QString &encryption, const QList<QByteArray> &senderKeyIds)
 {
     auto interface = std::make_shared<QFutureInterface<void>>(QFutureInterfaceBase::Started);
 
     auto future = m_trustStorage->keysForPostponedTrustDecisions(encryption, senderKeyIds);
-    await(future, this, [=](const QHash<bool, QMultiHash<QString, QString>> &&keysForPostponedTrustDecisions) {
+    await(future, this, [=](const QHash<bool, QMultiHash<QString, QByteArray>> &&keysForPostponedTrustDecisions) {
         // JIDs of key owners mapped to the IDs of their keys
         const auto keysBeingAuthenticated = keysForPostponedTrustDecisions.value(true);
         const auto keysBeingDistrusted = keysForPostponedTrustDecisions.value(false);
diff --git a/src/client/QXmppAtmManager.h b/src/client/QXmppAtmManager.h
index 2df2dfce..3b65d9db 100644
--- a/src/client/QXmppAtmManager.h
+++ b/src/client/QXmppAtmManager.h
@@ -36,7 +36,7 @@ class QXMPP_EXPORT QXmppAtmManager : public QXmppClientExtension
 
 public:
     QXmppAtmManager(QXmppTrustStorage *trustStorage);
-    QFuture<void> makeTrustDecisions(const QString &encryption, const QString &keyOwnerJid, const QList<QString> &keyIdsForAuthentication, const QList<QString> &keyIdsForDistrusting = {});
+    QFuture<void> makeTrustDecisions(const QString &encryption, const QString &keyOwnerJid, const QList<QByteArray> &keyIdsForAuthentication, const QList<QByteArray> &keyIdsForDistrusting = {});
 
     /// \cond
     bool handleStanza(const QDomElement &stanza) override;
@@ -49,14 +49,14 @@ private slots:
     /// \endcond
 
 private:
-    QFuture<void> makeTrustDecisions(const QString &encryption, const QMultiHash<QString, QString> &keyIdsForAuthentication, const QMultiHash<QString, QString> &keyIdsForDistrusting);
+    QFuture<void> makeTrustDecisions(const QString &encryption, const QMultiHash<QString, QByteArray> &keyIdsForAuthentication, const QMultiHash<QString, QByteArray> &keyIdsForDistrusting);
     QFuture<void> handleMessage(const QXmppMessage &message);
 
-    QFuture<void> authenticate(const QString &encryption, const QMultiHash<QString, QString> &keyIds);
-    QFuture<void> distrust(const QString &encryption, const QMultiHash<QString, QString> &keyIds);
+    QFuture<void> authenticate(const QString &encryption, const QMultiHash<QString, QByteArray> &keyIds);
+    QFuture<void> distrust(const QString &encryption, const QMultiHash<QString, QByteArray> &keyIds);
 
     QFuture<void> distrustAutomaticallyTrustedKeys(const QString &encryption, const QList<QString> &keyOwnerJids);
-    QFuture<void> makePostponedTrustDecisions(const QString &encryption, const QList<QString> &senderKeyIds);
+    QFuture<void> makePostponedTrustDecisions(const QString &encryption, const QList<QByteArray> &senderKeyIds);
 
     QFuture<QXmpp::SendResult> sendTrustMessage(const QString &encryption, const QList<QXmppTrustMessageKeyOwner> &keyOwners, const QString &recipientJid);
 
diff --git a/src/client/QXmppTrustMemoryStorage.cpp b/src/client/QXmppTrustMemoryStorage.cpp
index 1e2b5904..2a188a77 100644
--- a/src/client/QXmppTrustMemoryStorage.cpp
+++ b/src/client/QXmppTrustMemoryStorage.cpp
@@ -41,16 +41,16 @@ using namespace QXmpp::Private;
 
 struct ProcessedKey
 {
-    QString id;
+    QByteArray id;
     QString ownerJid;
     QXmppTrustStorage::TrustLevel trustLevel;
 };
 
 struct UnprocessedKey
 {
-    QString id;
+    QByteArray id;
     QString ownerJid;
-    QString senderKeyId;
+    QByteArray senderKeyId;
     bool trust;
 };
 
@@ -61,7 +61,7 @@ public:
     QMap<QString, QXmppTrustStorage::SecurityPolicy> securityPolicies;
 
     // encryption protocols mapped to keys of this client instance
-    QMap<QString, QString> ownKeys;
+    QMap<QString, QByteArray> ownKeys;
 
     // encryption protocols mapped to keys with specified trust levels
     QMultiHash<QString, ProcessedKey> processedKeys;
@@ -100,7 +100,7 @@ QFuture<QXmppTrustStorage::SecurityPolicy> QXmppTrustMemoryStorage::securityPoli
     return makeReadyFuture(std::move(d->securityPolicies.value(encryption)));
 }
 
-QFuture<void> QXmppTrustMemoryStorage::addOwnKey(const QString &encryption, const QString &keyId)
+QFuture<void> QXmppTrustMemoryStorage::addOwnKey(const QString &encryption, const QByteArray &keyId)
 {
     d->ownKeys.insert(encryption, keyId);
     return makeReadyFuture();
@@ -112,13 +112,13 @@ QFuture<void> QXmppTrustMemoryStorage::removeOwnKey(const QString &encryption)
     return makeReadyFuture();
 }
 
-QFuture<QString> QXmppTrustMemoryStorage::ownKey(const QString &encryption)
+QFuture<QByteArray> QXmppTrustMemoryStorage::ownKey(const QString &encryption)
 {
     auto key = d->ownKeys[encryption];
     return makeReadyFuture(std::move(key));
 }
 
-QFuture<void> QXmppTrustMemoryStorage::addKeys(const QString &encryption, const QString &keyOwnerJid, const QList<QString> &keyIds, const QXmppTrustStorage::TrustLevel trustLevel)
+QFuture<void> QXmppTrustMemoryStorage::addKeys(const QString &encryption, const QString &keyOwnerJid, const QList<QByteArray> &keyIds, const QXmppTrustStorage::TrustLevel trustLevel)
 {
     for (const auto &keyId : keyIds) {
         ProcessedKey key;
@@ -131,7 +131,7 @@ QFuture<void> QXmppTrustMemoryStorage::addKeys(const QString &encryption, const
     return makeReadyFuture();
 }
 
-QFuture<void> QXmppTrustMemoryStorage::removeKeys(const QString &encryption, const QList<QString> &keyIds)
+QFuture<void> QXmppTrustMemoryStorage::removeKeys(const QString &encryption, const QList<QByteArray> &keyIds)
 {
     if (encryption.isEmpty()) {
         d->processedKeys.clear();
@@ -151,9 +151,9 @@ QFuture<void> QXmppTrustMemoryStorage::removeKeys(const QString &encryption, con
     return makeReadyFuture();
 }
 
-QFuture<QHash<QXmppTrustStorage::TrustLevel, QMultiHash<QString, QString>>> QXmppTrustMemoryStorage::keys(const QString &encryption, const TrustLevels trustLevels)
+QFuture<QHash<QXmppTrustStorage::TrustLevel, QMultiHash<QString, QByteArray>>> QXmppTrustMemoryStorage::keys(const QString &encryption, const TrustLevels trustLevels)
 {
-    QHash<TrustLevel, QMultiHash<QString, QString>> keys;
+    QHash<TrustLevel, QMultiHash<QString, QByteArray>> keys;
 
     const auto processedKeys = d->processedKeys.values(encryption);
     for (const auto &key : processedKeys) {
@@ -166,7 +166,7 @@ QFuture<QHash<QXmppTrustStorage::TrustLevel, QMultiHash<QString, QString>>> QXmp
     return makeReadyFuture(std::move(keys));
 }
 
-QFuture<void> QXmppTrustMemoryStorage::setTrustLevel(const QString &encryption, const QMultiHash<QString, QString> &keyIds, const TrustLevel trustLevel)
+QFuture<void> QXmppTrustMemoryStorage::setTrustLevel(const QString &encryption, const QMultiHash<QString, QByteArray> &keyIds, const TrustLevel trustLevel)
 {
     for (auto itr = keyIds.constBegin(); itr != keyIds.constEnd(); ++itr) {
         const auto keyOwnerJid = itr.key();
@@ -214,7 +214,7 @@ QFuture<void> QXmppTrustMemoryStorage::setTrustLevel(const QString &encryption,
     return makeReadyFuture();
 }
 
-QFuture<QXmppTrustStorage::TrustLevel> QXmppTrustMemoryStorage::trustLevel(const QString &encryption, const QString &keyId)
+QFuture<QXmppTrustStorage::TrustLevel> QXmppTrustMemoryStorage::trustLevel(const QString &encryption, const QByteArray &keyId)
 {
     const auto processedKeys = d->processedKeys.values(encryption);
     for (const auto &key : processedKeys) {
@@ -226,9 +226,9 @@ QFuture<QXmppTrustStorage::TrustLevel> QXmppTrustMemoryStorage::trustLevel(const
     return makeReadyFuture(std::move(TrustLevel::AutomaticallyDistrusted));
 }
 
-QFuture<void> QXmppTrustMemoryStorage::addKeysForPostponedTrustDecisions(const QString &encryption, const QString &senderKeyId, const QList<QXmppTrustMessageKeyOwner> &keyOwners)
+QFuture<void> QXmppTrustMemoryStorage::addKeysForPostponedTrustDecisions(const QString &encryption, const QByteArray &senderKeyId, const QList<QXmppTrustMessageKeyOwner> &keyOwners)
 {
-    const auto addKeys = [&](const QXmppTrustMessageKeyOwner &keyOwner, bool trust, const QList<QString> &keyIds) {
+    const auto addKeys = [&](const QXmppTrustMessageKeyOwner &keyOwner, bool trust, const QList<QByteArray> &keyIds) {
         for (const auto &keyId : keyIds) {
             auto isKeyFound = false;
 
@@ -265,13 +265,13 @@ QFuture<void> QXmppTrustMemoryStorage::addKeysForPostponedTrustDecisions(const Q
     return makeReadyFuture();
 }
 
-QFuture<void> QXmppTrustMemoryStorage::removeKeysForPostponedTrustDecisions(const QString &encryption, const QList<QString> &keyIdsForAuthentication, const QList<QString> &keyIdsForDistrusting)
+QFuture<void> QXmppTrustMemoryStorage::removeKeysForPostponedTrustDecisions(const QString &encryption, const QList<QByteArray> &keyIdsForAuthentication, const QList<QByteArray> &keyIdsForDistrusting)
 {
     for (auto itr = d->unprocessedKeys.find(encryption);
          itr != d->unprocessedKeys.end() && itr.key() == encryption;) {
         const auto &key = itr.value();
         if ((key.trust && keyIdsForAuthentication.contains(key.id)) ||
-                (!key.trust && keyIdsForDistrusting.contains(key.id))) {
+            (!key.trust && keyIdsForDistrusting.contains(key.id))) {
             itr = d->unprocessedKeys.erase(itr);
         } else {
             ++itr;
@@ -280,7 +280,7 @@ QFuture<void> QXmppTrustMemoryStorage::removeKeysForPostponedTrustDecisions(cons
     return makeReadyFuture();
 }
 
-QFuture<void> QXmppTrustMemoryStorage::removeKeysForPostponedTrustDecisions(const QString &encryption, const QList<QString> &senderKeyIds)
+QFuture<void> QXmppTrustMemoryStorage::removeKeysForPostponedTrustDecisions(const QString &encryption, const QList<QByteArray> &senderKeyIds)
 {
     if (encryption.isEmpty()) {
         d->unprocessedKeys.clear();
@@ -300,9 +300,9 @@ QFuture<void> QXmppTrustMemoryStorage::removeKeysForPostponedTrustDecisions(cons
     return makeReadyFuture();
 }
 
-QFuture<QHash<bool, QMultiHash<QString, QString>>> QXmppTrustMemoryStorage::keysForPostponedTrustDecisions(const QString &encryption, const QList<QString> &senderKeyIds)
+QFuture<QHash<bool, QMultiHash<QString, QByteArray>>> QXmppTrustMemoryStorage::keysForPostponedTrustDecisions(const QString &encryption, const QList<QByteArray> &senderKeyIds)
 {
-    QHash<bool, QMultiHash<QString, QString>> keys;
+    QHash<bool, QMultiHash<QString, QByteArray>> keys;
 
     const auto unprocessedKeys = d->unprocessedKeys.values(encryption);
     for (const auto &key : unprocessedKeys) {
diff --git a/src/client/QXmppTrustMemoryStorage.h b/src/client/QXmppTrustMemoryStorage.h
index 82067b96..d097f035 100644
--- a/src/client/QXmppTrustMemoryStorage.h
+++ b/src/client/QXmppTrustMemoryStorage.h
@@ -41,22 +41,22 @@ public:
     QFuture<void> setSecurityPolicies(const QString &encryption = {}, SecurityPolicy securityPolicy = QXmppTrustStorage::NoSecurityPolicy) override;
     QFuture<SecurityPolicy> securityPolicy(const QString &encryption) override;
 
-    QFuture<void> addOwnKey(const QString &encryption, const QString &keyId) override;
+    QFuture<void> addOwnKey(const QString &encryption, const QByteArray &keyId) override;
     QFuture<void> removeOwnKey(const QString &encryption) override;
-    QFuture<QString> ownKey(const QString &encryption) override;
+    QFuture<QByteArray> ownKey(const QString &encryption) override;
 
-    QFuture<void> addKeys(const QString &encryption, const QString &keyOwnerJid, const QList<QString> &keyIds, TrustLevel trustLevel = TrustLevel::AutomaticallyDistrusted) override;
-    QFuture<void> removeKeys(const QString &encryption = {}, const QList<QString> &keyIds = {}) override;
-    QFuture<QHash<TrustLevel, QMultiHash<QString, QString>>> keys(const QString &encryption, TrustLevels trustLevels = {}) override;
+    QFuture<void> addKeys(const QString &encryption, const QString &keyOwnerJid, const QList<QByteArray> &keyIds, TrustLevel trustLevel = TrustLevel::AutomaticallyDistrusted) override;
+    QFuture<void> removeKeys(const QString &encryption = {}, const QList<QByteArray> &keyIds = {}) override;
+    QFuture<QHash<TrustLevel, QMultiHash<QString, QByteArray>>> keys(const QString &encryption, TrustLevels trustLevels = {}) override;
 
-    QFuture<void> setTrustLevel(const QString &encryption, const QMultiHash<QString, QString> &keyIds, const TrustLevel trustLevel) override;
+    QFuture<void> setTrustLevel(const QString &encryption, const QMultiHash<QString, QByteArray> &keyIds, const TrustLevel trustLevel) override;
     QFuture<void> setTrustLevel(const QString &encryption, const QList<QString> &keyOwnerJids, const TrustLevel oldTrustLevel, const TrustLevel newTrustLevel) override;
-    QFuture<TrustLevel> trustLevel(const QString &encryption, const QString &keyId) override;
+    QFuture<TrustLevel> trustLevel(const QString &encryption, const QByteArray &keyId) override;
 
-    QFuture<void> addKeysForPostponedTrustDecisions(const QString &encryption, const QString &senderKeyId, const QList<QXmppTrustMessageKeyOwner> &keyOwners) override;
-    QFuture<void> removeKeysForPostponedTrustDecisions(const QString &encryption, const QList<QString> &keyIdsForAuthentication, const QList<QString> &keyIdsForDistrusting) override;
-    QFuture<void> removeKeysForPostponedTrustDecisions(const QString &encryption = {}, const QList<QString> &senderKeyIds = {}) override;
-    QFuture<QHash<bool, QMultiHash<QString, QString>>> keysForPostponedTrustDecisions(const QString &encryption, const QList<QString> &senderKeyIds = {}) override;
+    QFuture<void> addKeysForPostponedTrustDecisions(const QString &encryption, const QByteArray &senderKeyId, const QList<QXmppTrustMessageKeyOwner> &keyOwners) override;
+    QFuture<void> removeKeysForPostponedTrustDecisions(const QString &encryption, const QList<QByteArray> &keyIdsForAuthentication, const QList<QByteArray> &keyIdsForDistrusting) override;
+    QFuture<void> removeKeysForPostponedTrustDecisions(const QString &encryption = {}, const QList<QByteArray> &senderKeyIds = {}) override;
+    QFuture<QHash<bool, QMultiHash<QString, QByteArray>>> keysForPostponedTrustDecisions(const QString &encryption, const QList<QByteArray> &senderKeyIds = {}) override;
     /// \endcond
 
 private:
diff --git a/src/client/QXmppTrustStorage.cpp b/src/client/QXmppTrustStorage.cpp
index 51ebea82..369470a4 100644
--- a/src/client/QXmppTrustStorage.cpp
+++ b/src/client/QXmppTrustStorage.cpp
@@ -57,7 +57,7 @@
 ///
 
 ///
-/// \fn QXmppTrustStorage::addOwnKey(const QString &encryption, const QString &keyId)
+/// \fn QXmppTrustStorage::addOwnKey(const QString &encryption, const QByteArray &keyId)
 ///
 /// Adds an own key (i.e., the key used by this client instance).
 ///
@@ -84,7 +84,7 @@
 ///
 
 ///
-/// \fn QXmppTrustStorage::addKeys(const QString &encryption, const QString &keyOwnerJid, const QList<QString> &keyIds, const QXmppTrustStorage::TrustLevel trustLevel)
+/// \fn QXmppTrustStorage::addKeys(const QString &encryption, const QString &keyOwnerJid, const QList<QByteArray> &keyIds, const QXmppTrustStorage::TrustLevel trustLevel)
 ///
 /// Adds keys.
 ///
@@ -95,7 +95,7 @@
 ///
 
 ///
-/// \fn QXmppTrustStorage::removeKeys(const QString &encryption, const QList<QString> &keyIds)
+/// \fn QXmppTrustStorage::removeKeys(const QString &encryption, const QList<QByteArray> &keyIds)
 ///
 /// Removes keys.
 ///
@@ -121,7 +121,7 @@
 ///
 
 ///
-/// \fn QXmppTrustStorage::setTrustLevel(const QString &encryption, const QMultiHash<QString, QString> &keyIds, TrustLevel trustLevel)
+/// \fn QXmppTrustStorage::setTrustLevel(const QString &encryption, const QMultiHash<QString, QByteArray> &keyIds, TrustLevel trustLevel)
 ///
 /// Sets the trust level of keys.
 ///
@@ -144,7 +144,7 @@
 ///
 
 ///
-/// \fn QXmppTrustStorage::trustLevel(const QString &encryption, const QString &keyId)
+/// \fn QXmppTrustStorage::trustLevel(const QString &encryption, const QByteArray &keyId)
 ///
 /// Returns the trust level of a key.
 ///
@@ -157,7 +157,7 @@
 ///
 
 ///
-/// \fn QXmppTrustStorage::addKeysForPostponedTrustDecisions(const QString &encryption, const QString &senderKeyId, const QList<QXmppTrustMessageKeyOwner> &keyOwners)
+/// \fn QXmppTrustStorage::addKeysForPostponedTrustDecisions(const QString &encryption, const QByteArray &senderKeyId, const QList<QXmppTrustMessageKeyOwner> &keyOwners)
 ///
 /// Adds keys that cannot be authenticated or distrusted directly because the
 /// key of the trust message's sender is not yet authenticated.
@@ -181,7 +181,7 @@
 ///
 
 ///
-/// \fn QXmppTrustStorage::removeKeysForPostponedTrustDecisions(const QString &encryption, const QList<QString> &keyIdsForAuthentication, const QList<QString> &keyIdsForDistrusting)
+/// \fn QXmppTrustStorage::removeKeysForPostponedTrustDecisions(const QString &encryption, const QList<QByteArray> &keyIdsForAuthentication, const QList<QByteArray> &keyIdsForDistrusting)
 ///
 /// Removes keys for postponed authentication or distrusting.
 ///
@@ -191,7 +191,7 @@
 ///
 
 ///
-/// \fn QXmppTrustStorage::removeKeysForPostponedTrustDecisions(const QString &encryption = {}, const QList<QString> &senderKeyIds = {})
+/// \fn QXmppTrustStorage::removeKeysForPostponedTrustDecisions(const QString &encryption = {}, const QList<QByteArray> &senderKeyIds = {})
 ///
 /// Removes keys for postponed authentication or distrusting by the trust
 /// message's sender's key ID.
@@ -204,7 +204,7 @@
 ///
 
 ///
-/// \fn QXmppTrustStorage::keysForPostponedTrustDecisions(const QString &encryption, const QList<QString> &senderKeyIds = {})
+/// \fn QXmppTrustStorage::keysForPostponedTrustDecisions(const QString &encryption, const QList<QByteArray> &senderKeyIds = {})
 ///
 /// Returns the JIDs of key owners mapped to the IDs of their keys stored for
 /// postponed authentication (true) or postponed distrusting (false).
diff --git a/src/client/QXmppTrustStorage.h b/src/client/QXmppTrustStorage.h
index a18b1362..4d32e341 100644
--- a/src/client/QXmppTrustStorage.h
+++ b/src/client/QXmppTrustStorage.h
@@ -60,22 +60,22 @@ public:
     virtual QFuture<void> setSecurityPolicies(const QString &encryption = {}, SecurityPolicy securityPolicy = SecurityPolicy::NoSecurityPolicy) = 0;
     virtual QFuture<SecurityPolicy> securityPolicy(const QString &encryption) = 0;
 
-    virtual QFuture<void> addOwnKey(const QString &encryption, const QString &keyId) = 0;
+    virtual QFuture<void> addOwnKey(const QString &encryption, const QByteArray &keyId) = 0;
     virtual QFuture<void> removeOwnKey(const QString &encryption) = 0;
-    virtual QFuture<QString> ownKey(const QString &encryption) = 0;
+    virtual QFuture<QByteArray> ownKey(const QString &encryption) = 0;
 
-    virtual QFuture<void> addKeys(const QString &encryption, const QString &keyOwnerJid, const QList<QString> &keyIds, TrustLevel trustLevel = TrustLevel::AutomaticallyDistrusted) = 0;
-    virtual QFuture<void> removeKeys(const QString &encryption = {}, const QList<QString> &keyIds = {}) = 0;
-    virtual QFuture<QHash<TrustLevel, QMultiHash<QString, QString>>> keys(const QString &encryption, TrustLevels trustLevels = {}) = 0;
+    virtual QFuture<void> addKeys(const QString &encryption, const QString &keyOwnerJid, const QList<QByteArray> &keyIds, TrustLevel trustLevel = TrustLevel::AutomaticallyDistrusted) = 0;
+    virtual QFuture<void> removeKeys(const QString &encryption = {}, const QList<QByteArray> &keyIds = {}) = 0;
+    virtual QFuture<QHash<TrustLevel, QMultiHash<QString, QByteArray>>> keys(const QString &encryption, TrustLevels trustLevels = {}) = 0;
 
-    virtual QFuture<void> setTrustLevel(const QString &encryption, const QMultiHash<QString, QString> &keyIds, TrustLevel trustLevel) = 0;
+    virtual QFuture<void> setTrustLevel(const QString &encryption, const QMultiHash<QString, QByteArray> &keyIds, TrustLevel trustLevel) = 0;
     virtual QFuture<void> setTrustLevel(const QString &encryption, const QList<QString> &keyOwnerJids, TrustLevel oldTrustLevel, TrustLevel newTrustLevel) = 0;
-    virtual QFuture<TrustLevel> trustLevel(const QString &encryption, const QString &keyId) = 0;
+    virtual QFuture<TrustLevel> trustLevel(const QString &encryption, const QByteArray &keyId) = 0;
 
-    virtual QFuture<void> addKeysForPostponedTrustDecisions(const QString &encryption, const QString &senderKeyId, const QList<QXmppTrustMessageKeyOwner> &keyOwners) = 0;
-    virtual QFuture<void> removeKeysForPostponedTrustDecisions(const QString &encryption, const QList<QString> &keyIdsForAuthentication, const QList<QString> &keyIdsForDistrusting) = 0;
-    virtual QFuture<void> removeKeysForPostponedTrustDecisions(const QString &encryption = {}, const QList<QString> &senderKeyIds = {}) = 0;
-    virtual QFuture<QHash<bool, QMultiHash<QString, QString>>> keysForPostponedTrustDecisions(const QString &encryption, const QList<QString> &senderKeyIds = {}) = 0;
+    virtual QFuture<void> addKeysForPostponedTrustDecisions(const QString &encryption, const QByteArray &senderKeyId, const QList<QXmppTrustMessageKeyOwner> &keyOwners) = 0;
+    virtual QFuture<void> removeKeysForPostponedTrustDecisions(const QString &encryption, const QList<QByteArray> &keyIdsForAuthentication, const QList<QByteArray> &keyIdsForDistrusting) = 0;
+    virtual QFuture<void> removeKeysForPostponedTrustDecisions(const QString &encryption = {}, const QList<QByteArray> &senderKeyIds = {}) = 0;
+    virtual QFuture<QHash<bool, QMultiHash<QString, QByteArray>>> keysForPostponedTrustDecisions(const QString &encryption, const QList<QByteArray> &senderKeyIds = {}) = 0;
 };
 
 Q_DECLARE_METATYPE(QXmppTrustStorage::SecurityPolicy)