From bcc05aa1d52cae2b6d8e70bb6cf04fa49904687a Mon Sep 17 00:00:00 2001
From: Alexey Rusakov <Kitsune-Ral@users.sf.net>
Date: Wed, 21 Sep 2022 15:45:59 +0200
Subject: Cleanup across E2EE code
Notably:
- simplified unnecessarily verbose constructs;
- formally aligned (no re-numeration was necessary)
QOlmMessage::Type with corresponding OLM_ constants;
- dropped QOlmSession::encryptMessageType() because it's very
sensitive to the order of calling with QOlmSession::encrypt()
(and encrypt() itself already calls it and returns the message
type);
- simplify the return type of pickle() calls that can only fail due to
an internal error;
- replace const QString& with QStringView or const QByteArray&
where appropriate;
- use '\0' where it was meant to be instead of '0'.
---
lib/connection.cpp | 8 ++--
lib/e2ee/e2ee.h | 2 +-
lib/e2ee/qolmaccount.cpp | 54 +++++++++++-----------
lib/e2ee/qolmaccount.h | 9 ++--
lib/e2ee/qolminboundsession.cpp | 57 +++++++++++-------------
lib/e2ee/qolminboundsession.h | 4 +-
lib/e2ee/qolmmessage.cpp | 6 ---
lib/e2ee/qolmmessage.h | 12 +++--
lib/e2ee/qolmoutboundsession.cpp | 44 +++++++++---------
lib/e2ee/qolmoutboundsession.h | 4 +-
lib/e2ee/qolmsession.cpp | 96 +++++++++++++++-------------------------
lib/e2ee/qolmsession.h | 15 +++----
lib/e2ee/qolmutility.cpp | 24 +++++-----
lib/e2ee/qolmutils.h | 1 +
lib/events/filesourceinfo.cpp | 35 ++++++---------
lib/keyverificationsession.cpp | 6 +--
16 files changed, 166 insertions(+), 211 deletions(-)
(limited to 'lib')
diff --git a/lib/connection.cpp b/lib/connection.cpp
index 865dff79..f38bb751 100644
--- a/lib/connection.cpp
+++ b/lib/connection.cpp
@@ -652,8 +652,7 @@ void Connection::Private::completeSetup(const QString& mxId)
});
} else {
// account already existing
- auto pickle = database->accountPickle();
- olmAccount->unpickle(pickle, picklingMode);
+ olmAccount->unpickle(database->accountPickle(), picklingMode);
}
#endif // Quotient_E2EE_ENABLED
emit q->stateChanged();
@@ -2300,14 +2299,13 @@ std::pair<QOlmMessage::Type, QByteArray> Connection::Private::olmEncryptMessage(
{
const auto& curveKey = curveKeyForUserDevice(userId, device);
const auto& olmSession = olmSessions.at(curveKey).front();
- QOlmMessage::Type type = olmSession->encryptMessageType();
const auto result = olmSession->encrypt(message);
if (const auto pickle = olmSession->pickle(picklingMode)) {
database->updateOlmSession(curveKey, olmSession->sessionId(), *pickle);
} else {
qWarning(E2EE) << "Failed to pickle olm session: " << pickle.error();
}
- return { type, result.toCiphertext() };
+ return { result.type(), result.toCiphertext() };
}
bool Connection::Private::createOlmSession(const QString& targetUserId,
@@ -2343,7 +2341,7 @@ bool Connection::Private::createOlmSession(const QString& targetUserId,
return false;
}
const auto recipientCurveKey =
- curveKeyForUserDevice(targetUserId, targetDeviceId);
+ curveKeyForUserDevice(targetUserId, targetDeviceId).toLatin1();
auto session =
QOlmSession::createOutboundSession(olmAccount.get(), recipientCurveKey,
signedOneTimeKey->key());
diff --git a/lib/e2ee/e2ee.h b/lib/e2ee/e2ee.h
index 51ceff67..5999c0be 100644
--- a/lib/e2ee/e2ee.h
+++ b/lib/e2ee/e2ee.h
@@ -98,7 +98,7 @@ public:
{}
//! Unpadded Base64-encoded 32-byte Curve25519 public key
- QString key() const { return payload["key"_ls].toString(); }
+ QByteArray key() const { return payload["key"_ls].toString().toLatin1(); }
//! \brief Signatures of the key object
//!
diff --git a/lib/e2ee/qolmaccount.cpp b/lib/e2ee/qolmaccount.cpp
index d33db8e3..556a8274 100644
--- a/lib/e2ee/qolmaccount.cpp
+++ b/lib/e2ee/qolmaccount.cpp
@@ -27,11 +27,11 @@ const char* QOlmAccount::lastError() const
return olm_account_last_error(m_account);
}
-QOlmAccount::QOlmAccount(const QString& userId, const QString& deviceId,
+QOlmAccount::QOlmAccount(QStringView userId, QStringView deviceId,
QObject* parent)
: QObject(parent)
- , m_userId(userId)
- , m_deviceId(deviceId)
+ , m_userId(userId.toString())
+ , m_deviceId(deviceId.toString())
{}
QOlmAccount::~QOlmAccount()
@@ -43,20 +43,20 @@ QOlmAccount::~QOlmAccount()
void QOlmAccount::createNewAccount()
{
m_account = olm_account(new uint8_t[olm_account_size()]);
- size_t randomSize = olm_create_account_random_length(m_account);
- QByteArray randomData = getRandom(randomSize);
- if (olm_create_account(m_account, randomData.data(), randomSize)
+ const auto randomLength = olm_create_account_random_length(m_account);
+ QByteArray randomData = getRandom(randomLength);
+ if (olm_create_account(m_account, randomData.data(), randomLength)
== olm_error()) {
throw lastError();
}
emit needsSave();
}
-OlmErrorCode QOlmAccount::unpickle(QByteArray &pickled, const PicklingMode &mode)
+OlmErrorCode QOlmAccount::unpickle(QByteArray&& pickled, const PicklingMode &mode)
{
m_account = olm_account(new uint8_t[olm_account_size()]);
- const QByteArray key = toKey(mode);
- if (olm_unpickle_account(m_account, key.data(), key.length(),
+ if (const auto key = toKey(mode);
+ olm_unpickle_account(m_account, key.data(), key.length(),
pickled.data(), pickled.size())
== olm_error()) {
// Probably log the user out since we have no way of getting to the keys
@@ -69,7 +69,7 @@ QOlmExpected<QByteArray> QOlmAccount::pickle(const PicklingMode &mode)
{
const QByteArray key = toKey(mode);
const size_t pickleLength = olm_pickle_account_length(m_account);
- QByteArray pickleBuffer(pickleLength, '0');
+ QByteArray pickleBuffer(pickleLength, '\0');
if (olm_pickle_account(m_account, key.data(), key.length(),
pickleBuffer.data(), pickleLength)
== olm_error())
@@ -80,12 +80,12 @@ QOlmExpected<QByteArray> QOlmAccount::pickle(const PicklingMode &mode)
IdentityKeys QOlmAccount::identityKeys() const
{
const size_t keyLength = olm_account_identity_keys_length(m_account);
- QByteArray keyBuffer(keyLength, '0');
+ QByteArray keyBuffer(keyLength, '\0');
if (olm_account_identity_keys(m_account, keyBuffer.data(), keyLength)
== olm_error()) {
throw lastError();
}
- const QJsonObject key = QJsonDocument::fromJson(keyBuffer).object();
+ const auto key = QJsonDocument::fromJson(keyBuffer).object();
return IdentityKeys {
key.value(QStringLiteral("curve25519")).toString().toUtf8(),
key.value(QStringLiteral("ed25519")).toString().toUtf8()
@@ -94,7 +94,7 @@ IdentityKeys QOlmAccount::identityKeys() const
QByteArray QOlmAccount::sign(const QByteArray &message) const
{
- QByteArray signatureBuffer(olm_account_signature_length(m_account), '0');
+ QByteArray signatureBuffer(olm_account_signature_length(m_account), '\0');
if (olm_account_sign(m_account, message.data(), message.length(),
signatureBuffer.data(), signatureBuffer.length())
@@ -112,15 +112,15 @@ QByteArray QOlmAccount::sign(const QJsonObject &message) const
QByteArray QOlmAccount::signIdentityKeys() const
{
const auto keys = identityKeys();
- return sign(QJsonObject {
- { "algorithms", QJsonArray { "m.olm.v1.curve25519-aes-sha2",
- "m.megolm.v1.aes-sha2" } },
+ return sign(QJsonObject{
+ { "algorithms", QJsonArray{ "m.olm.v1.curve25519-aes-sha2",
+ "m.megolm.v1.aes-sha2" } },
{ "user_id", m_userId },
{ "device_id", m_deviceId },
- { "keys", QJsonObject { { QStringLiteral("curve25519:") + m_deviceId,
- QString::fromUtf8(keys.curve25519) },
- { QStringLiteral("ed25519:") + m_deviceId,
- QString::fromUtf8(keys.ed25519) } } } });
+ { "keys", QJsonObject{ { QStringLiteral("curve25519:") + m_deviceId,
+ QString::fromUtf8(keys.curve25519) },
+ { QStringLiteral("ed25519:") + m_deviceId,
+ QString::fromUtf8(keys.ed25519) } } } });
}
size_t QOlmAccount::maxNumberOfOneTimeKeys() const
@@ -130,7 +130,7 @@ size_t QOlmAccount::maxNumberOfOneTimeKeys() const
size_t QOlmAccount::generateOneTimeKeys(size_t numberOfKeys)
{
- const size_t randomLength =
+ const auto randomLength =
olm_account_generate_one_time_keys_random_length(m_account,
numberOfKeys);
QByteArray randomBuffer = getRandom(randomLength);
@@ -147,8 +147,8 @@ size_t QOlmAccount::generateOneTimeKeys(size_t numberOfKeys)
UnsignedOneTimeKeys QOlmAccount::oneTimeKeys() const
{
- const size_t oneTimeKeyLength = olm_account_one_time_keys_length(m_account);
- QByteArray oneTimeKeysBuffer(static_cast<int>(oneTimeKeyLength), '0');
+ const auto oneTimeKeyLength = olm_account_one_time_keys_length(m_account);
+ QByteArray oneTimeKeysBuffer(static_cast<int>(oneTimeKeyLength), '\0');
if (olm_account_one_time_keys(m_account, oneTimeKeysBuffer.data(),
oneTimeKeyLength)
@@ -193,13 +193,13 @@ DeviceKeys QOlmAccount::deviceKeys() const
SupportedAlgorithms.cend());
const auto idKeys = identityKeys();
- return DeviceKeys {
+ return DeviceKeys{
.userId = m_userId,
.deviceId = m_deviceId,
.algorithms = Algorithms,
- .keys { { "curve25519:" + m_deviceId, idKeys.curve25519 },
- { "ed25519:" + m_deviceId, idKeys.ed25519 } },
- .signatures {
+ .keys{ { "curve25519:" + m_deviceId, idKeys.curve25519 },
+ { "ed25519:" + m_deviceId, idKeys.ed25519 } },
+ .signatures{
{ m_userId, { { "ed25519:" + m_deviceId, signIdentityKeys() } } } }
};
}
diff --git a/lib/e2ee/qolmaccount.h b/lib/e2ee/qolmaccount.h
index 5ad98e47..0fb9803f 100644
--- a/lib/e2ee/qolmaccount.h
+++ b/lib/e2ee/qolmaccount.h
@@ -24,7 +24,8 @@ class QUOTIENT_API QOlmAccount : public QObject
{
Q_OBJECT
public:
- QOlmAccount(const QString &userId, const QString &deviceId, QObject *parent = nullptr);
+ QOlmAccount(QStringView userId, QStringView deviceId,
+ QObject* parent = nullptr);
~QOlmAccount() override;
//! Creates a new instance of OlmAccount. During the instantiation
@@ -36,7 +37,7 @@ public:
//! Deserialises from encrypted Base64 that was previously obtained by pickling a `QOlmAccount`.
//! This needs to be called before any other action or use createNewAccount() instead.
- [[nodiscard]] OlmErrorCode unpickle(QByteArray& pickled,
+ [[nodiscard]] OlmErrorCode unpickle(QByteArray&& pickled,
const PicklingMode& mode);
//! Serialises an OlmAccount to encrypted Base64.
@@ -74,7 +75,7 @@ public:
//! Creates an inbound session for sending/receiving messages from a received 'prekey' message.
//!
- //! \param message An Olm pre-key message that was encrypted for this account.
+ //! \param preKeyMessage An Olm pre-key message that was encrypted for this account.
QOlmExpected<QOlmSessionPtr> createInboundSession(
const QOlmMessage& preKeyMessage);
@@ -93,7 +94,7 @@ public:
void markKeysAsPublished();
OlmErrorCode lastErrorCode() const;
- const char *lastError() const;
+ const char* lastError() const;
// HACK do not use directly
QOlmAccount(OlmAccount *account);
diff --git a/lib/e2ee/qolminboundsession.cpp b/lib/e2ee/qolminboundsession.cpp
index 870070c2..a05ddf62 100644
--- a/lib/e2ee/qolminboundsession.cpp
+++ b/lib/e2ee/qolminboundsession.cpp
@@ -2,8 +2,9 @@
//
// SPDX-License-Identifier: LGPL-2.1-or-later
-#include "e2ee/qolminboundsession.h"
-#include "logging.h"
+#include "qolminboundsession.h"
+#include "qolmutils.h"
+#include "../logging.h"
#include <cstring>
#include <iostream>
@@ -37,7 +38,7 @@ std::unique_ptr<QOlmInboundGroupSession> QOlmInboundGroupSession::create(const Q
olmInboundGroupSession,
reinterpret_cast<const uint8_t*>(key.constData()), key.size())
== olm_error()) {
- // FIXME: create QOlmInboundGroupSession earlier and use lastError()
+ // FIXME: create QOlmInboundGroupSession earlier and use lastErrorCode()
throw olm_inbound_group_session_last_error_code(olmInboundGroupSession);
}
@@ -47,11 +48,10 @@ std::unique_ptr<QOlmInboundGroupSession> QOlmInboundGroupSession::create(const Q
std::unique_ptr<QOlmInboundGroupSession> QOlmInboundGroupSession::import(const QByteArray &key)
{
const auto olmInboundGroupSession = olm_inbound_group_session(new uint8_t[olm_inbound_group_session_size()]);
- QByteArray keyBuf = key;
if (olm_import_inbound_group_session(
olmInboundGroupSession,
- reinterpret_cast<const uint8_t*>(keyBuf.data()), keyBuf.size())
+ reinterpret_cast<const uint8_t*>(key.data()), key.size())
== olm_error()) {
// FIXME: create QOlmInboundGroupSession earlier and use lastError()
throw olm_inbound_group_session_last_error_code(olmInboundGroupSession);
@@ -60,19 +60,12 @@ std::unique_ptr<QOlmInboundGroupSession> QOlmInboundGroupSession::import(const Q
return std::make_unique<QOlmInboundGroupSession>(olmInboundGroupSession);
}
-QByteArray toKey(const PicklingMode &mode)
-{
- if (std::holds_alternative<Unencrypted>(mode)) {
- return "";
- }
- return std::get<Encrypted>(mode).key;
-}
-
-QByteArray QOlmInboundGroupSession::pickle(const PicklingMode &mode) const
+QByteArray QOlmInboundGroupSession::pickle(const PicklingMode& mode) const
{
- QByteArray pickledBuf(olm_pickle_inbound_group_session_length(m_groupSession), '0');
- const QByteArray key = toKey(mode);
- if (olm_pickle_inbound_group_session(m_groupSession, key.data(),
+ QByteArray pickledBuf(
+ olm_pickle_inbound_group_session_length(m_groupSession), '\0');
+ if (const auto key = toKey(mode);
+ olm_pickle_inbound_group_session(m_groupSession, key.data(),
key.length(), pickledBuf.data(),
pickledBuf.length())
== olm_error()) {
@@ -82,14 +75,13 @@ QByteArray QOlmInboundGroupSession::pickle(const PicklingMode &mode) const
}
QOlmExpected<QOlmInboundGroupSessionPtr> QOlmInboundGroupSession::unpickle(
- const QByteArray& pickled, const PicklingMode& mode)
+ QByteArray&& pickled, const PicklingMode& mode)
{
- QByteArray pickledBuf = pickled;
const auto groupSession = olm_inbound_group_session(new uint8_t[olm_inbound_group_session_size()]);
- QByteArray key = toKey(mode);
+ auto key = toKey(mode);
if (olm_unpickle_inbound_group_session(groupSession, key.data(),
- key.length(), pickledBuf.data(),
- pickledBuf.size())
+ key.length(), pickled.data(),
+ pickled.size())
== olm_error()) {
// FIXME: create QOlmInboundGroupSession earlier and use lastError()
return olm_inbound_group_session_last_error_code(groupSession);
@@ -107,13 +99,16 @@ QOlmExpected<std::pair<QByteArray, uint32_t>> QOlmInboundGroupSession::decrypt(
// We need to clone the message because
// olm_decrypt_max_plaintext_length destroys the input buffer
- QByteArray messageBuf(message.length(), '0');
+ QByteArray messageBuf(message.length(), '\0');
std::copy(message.begin(), message.end(), messageBuf.begin());
- QByteArray plaintextBuf(olm_group_decrypt_max_plaintext_length(m_groupSession,
- reinterpret_cast<uint8_t *>(messageBuf.data()), messageBuf.length()), '0');
+ QByteArray plaintextBuf(olm_group_decrypt_max_plaintext_length(
+ m_groupSession,
+ reinterpret_cast<uint8_t*>(messageBuf.data()),
+ messageBuf.length()),
+ '\0');
- messageBuf = QByteArray(message.length(), '0');
+ messageBuf = QByteArray(message.length(), '\0');
std::copy(message.begin(), message.end(), messageBuf.begin());
const auto plaintextLen = olm_group_decrypt(m_groupSession, reinterpret_cast<uint8_t *>(messageBuf.data()),
@@ -123,16 +118,17 @@ QOlmExpected<std::pair<QByteArray, uint32_t>> QOlmInboundGroupSession::decrypt(
return lastErrorCode();
}
- QByteArray output(plaintextLen, '0');
+ QByteArray output(plaintextLen, '\0');
std::memcpy(output.data(), plaintextBuf.data(), plaintextLen);
return std::make_pair(output, messageIndex);
}
-QOlmExpected<QByteArray> QOlmInboundGroupSession::exportSession(uint32_t messageIndex)
+QOlmExpected<QByteArray> QOlmInboundGroupSession::exportSession(
+ uint32_t messageIndex)
{
const auto keyLength = olm_export_inbound_group_session_length(m_groupSession);
- QByteArray keyBuf(keyLength, '0');
+ QByteArray keyBuf(keyLength, '\0');
if (olm_export_inbound_group_session(
m_groupSession, reinterpret_cast<uint8_t*>(keyBuf.data()),
keyLength, messageIndex)
@@ -149,7 +145,8 @@ uint32_t QOlmInboundGroupSession::firstKnownIndex() const
QByteArray QOlmInboundGroupSession::sessionId() const
{
- QByteArray sessionIdBuf(olm_inbound_group_session_id_length(m_groupSession), '0');
+ QByteArray sessionIdBuf(olm_inbound_group_session_id_length(m_groupSession),
+ '\0');
if (olm_inbound_group_session_id(
m_groupSession, reinterpret_cast<uint8_t*>(sessionIdBuf.data()),
sessionIdBuf.length())
diff --git a/lib/e2ee/qolminboundsession.h b/lib/e2ee/qolminboundsession.h
index e8da6355..0b89349a 100644
--- a/lib/e2ee/qolminboundsession.h
+++ b/lib/e2ee/qolminboundsession.h
@@ -21,11 +21,11 @@ public:
//! Import an inbound group session, from a previous export.
static std::unique_ptr<QOlmInboundGroupSession> import(const QByteArray& key);
//! Serialises an `OlmInboundGroupSession` to encrypted Base64.
- QByteArray pickle(const PicklingMode &mode) const;
+ QByteArray pickle(const PicklingMode& mode) const;
//! Deserialises from encrypted Base64 that was previously obtained by pickling
//! an `OlmInboundGroupSession`.
static QOlmExpected<QOlmInboundGroupSessionPtr> unpickle(
- const QByteArray& pickled, const PicklingMode& mode);
+ QByteArray&& pickled, const PicklingMode& mode);
//! Decrypts ciphertext received for this group session.
QOlmExpected<std::pair<QByteArray, uint32_t> > decrypt(const QByteArray& message);
//! Export the base64-encoded ratchet key for this session, at the given index,
diff --git a/lib/e2ee/qolmmessage.cpp b/lib/e2ee/qolmmessage.cpp
index f9b4a5c2..b9cb8bd2 100644
--- a/lib/e2ee/qolmmessage.cpp
+++ b/lib/e2ee/qolmmessage.cpp
@@ -15,12 +15,6 @@ QOlmMessage::QOlmMessage(QByteArray ciphertext, QOlmMessage::Type type)
Q_ASSERT_X(!isEmpty(), "olm message", "Ciphertext is empty");
}
-QOlmMessage::QOlmMessage(const QOlmMessage &message)
- : QByteArray(message)
- , m_messageType(message.type())
-{
-}
-
QOlmMessage::Type QOlmMessage::type() const
{
return m_messageType;
diff --git a/lib/e2ee/qolmmessage.h b/lib/e2ee/qolmmessage.h
index b4285a93..ea73b3e3 100644
--- a/lib/e2ee/qolmmessage.h
+++ b/lib/e2ee/qolmmessage.h
@@ -6,8 +6,9 @@
#include "quotient_export.h"
-#include <QObject>
-#include <QByteArray>
+#include <QtCore/QByteArray>
+#include <qobjectdefs.h>
+#include <olm/olm.h>
namespace Quotient {
@@ -22,15 +23,12 @@ class QUOTIENT_API QOlmMessage : public QByteArray {
Q_GADGET
public:
enum Type {
- PreKey = 0,
- General,
+ PreKey = OLM_MESSAGE_TYPE_PRE_KEY,
+ General = OLM_MESSAGE_TYPE_MESSAGE,
};
Q_ENUM(Type)
- QOlmMessage() = default;
explicit QOlmMessage(QByteArray ciphertext, Type type = General);
- explicit QOlmMessage(const QOlmMessage &message);
- ~QOlmMessage() = default;
static QOlmMessage fromCiphertext(const QByteArray &ciphertext);
diff --git a/lib/e2ee/qolmoutboundsession.cpp b/lib/e2ee/qolmoutboundsession.cpp
index 79c16e01..22107a21 100644
--- a/lib/e2ee/qolmoutboundsession.cpp
+++ b/lib/e2ee/qolmoutboundsession.cpp
@@ -2,9 +2,10 @@
//
// SPDX-License-Identifier: LGPL-2.1-or-later
-#include "e2ee/qolmoutboundsession.h"
+#include "qolmoutboundsession.h"
-#include "e2ee/qolmutils.h"
+#include "logging.h"
+#include "qolmutils.h"
#include <olm/olm.h>
@@ -43,8 +44,9 @@ QOlmOutboundGroupSessionPtr QOlmOutboundGroupSession::create()
throw olm_outbound_group_session_last_error_code(olmOutboundGroupSession);
}
+ // FIXME: is it used anywhere?
const auto keyMaxLength = olm_outbound_group_session_key_length(olmOutboundGroupSession);
- QByteArray keyBuffer(keyMaxLength, '0');
+ QByteArray keyBuffer(keyMaxLength, '\0');
olm_outbound_group_session_key(olmOutboundGroupSession, reinterpret_cast<uint8_t *>(keyBuffer.data()),
keyMaxLength);
@@ -55,8 +57,9 @@ QOlmOutboundGroupSessionPtr QOlmOutboundGroupSession::create()
QOlmExpected<QByteArray> QOlmOutboundGroupSession::pickle(const PicklingMode &mode) const
{
- QByteArray pickledBuf(olm_pickle_outbound_group_session_length(m_groupSession), '0');
- QByteArray key = toKey(mode);
+ QByteArray pickledBuf(
+ olm_pickle_outbound_group_session_length(m_groupSession), '\0');
+ auto key = toKey(mode);
if (olm_pickle_outbound_group_session(m_groupSession, key.data(),
key.length(), pickledBuf.data(),
pickledBuf.length())
@@ -64,40 +67,41 @@ QOlmExpected<QByteArray> QOlmOutboundGroupSession::pickle(const PicklingMode &mo
return lastErrorCode();
key.clear();
-
return pickledBuf;
}
-QOlmExpected<QOlmOutboundGroupSessionPtr> QOlmOutboundGroupSession::unpickle(const QByteArray &pickled, const PicklingMode &mode)
+QOlmExpected<QOlmOutboundGroupSessionPtr> QOlmOutboundGroupSession::unpickle(
+ QByteArray&& pickled, const PicklingMode& mode)
{
- QByteArray pickledBuf = pickled;
auto *olmOutboundGroupSession = olm_outbound_group_session(new uint8_t[olm_outbound_group_session_size()]);
- QByteArray key = toKey(mode);
+ auto key = toKey(mode);
if (olm_unpickle_outbound_group_session(olmOutboundGroupSession, key.data(),
- key.length(), pickledBuf.data(),
- pickledBuf.length())
+ key.length(), pickled.data(),
+ pickled.length())
== olm_error()) {
// FIXME: create the session object earlier and use lastError()
return olm_outbound_group_session_last_error_code(
olmOutboundGroupSession);
}
const auto idMaxLength = olm_outbound_group_session_id_length(olmOutboundGroupSession);
- QByteArray idBuffer(idMaxLength, '0');
+ QByteArray idBuffer(idMaxLength, '\0');
olm_outbound_group_session_id(olmOutboundGroupSession, reinterpret_cast<uint8_t *>(idBuffer.data()),
idBuffer.length());
+ // FIXME: idBuffer doesn't seem to be used, is it needed here?
key.clear();
return std::make_unique<QOlmOutboundGroupSession>(olmOutboundGroupSession);
}
-QOlmExpected<QByteArray> QOlmOutboundGroupSession::encrypt(const QString &plaintext) const
+QOlmExpected<QByteArray> QOlmOutboundGroupSession::encrypt(
+ const QByteArray& plaintext) const
{
- QByteArray plaintextBuf = plaintext.toUtf8();
- const auto messageMaxLength = olm_group_encrypt_message_length(m_groupSession, plaintextBuf.length());
- QByteArray messageBuf(messageMaxLength, '0');
+ const auto messageMaxLength =
+ olm_group_encrypt_message_length(m_groupSession, plaintext.length());
+ QByteArray messageBuf(messageMaxLength, '\0');
if (olm_group_encrypt(m_groupSession,
- reinterpret_cast<uint8_t*>(plaintextBuf.data()),
- plaintextBuf.length(),
+ reinterpret_cast<const uint8_t*>(plaintext.data()),
+ plaintext.length(),
reinterpret_cast<uint8_t*>(messageBuf.data()),
messageBuf.length())
== olm_error())
@@ -114,7 +118,7 @@ uint32_t QOlmOutboundGroupSession::sessionMessageIndex() const
QByteArray QOlmOutboundGroupSession::sessionId() const
{
const auto idMaxLength = olm_outbound_group_session_id_length(m_groupSession);
- QByteArray idBuffer(idMaxLength, '0');
+ QByteArray idBuffer(idMaxLength, '\0');
if (olm_outbound_group_session_id(
m_groupSession, reinterpret_cast<uint8_t*>(idBuffer.data()),
idBuffer.length())
@@ -127,7 +131,7 @@ QByteArray QOlmOutboundGroupSession::sessionId() const
QOlmExpected<QByteArray> QOlmOutboundGroupSession::sessionKey() const
{
const auto keyMaxLength = olm_outbound_group_session_key_length(m_groupSession);
- QByteArray keyBuffer(keyMaxLength, '0');
+ QByteArray keyBuffer(keyMaxLength, '\0');
if (olm_outbound_group_session_key(
m_groupSession, reinterpret_cast<uint8_t*>(keyBuffer.data()),
keyMaxLength)
diff --git a/lib/e2ee/qolmoutboundsession.h b/lib/e2ee/qolmoutboundsession.h
index cd26fc67..e5e73ddf 100644
--- a/lib/e2ee/qolmoutboundsession.h
+++ b/lib/e2ee/qolmoutboundsession.h
@@ -24,10 +24,10 @@ public:
//! Deserialises from encrypted Base64 that was previously obtained by
//! pickling a `QOlmOutboundGroupSession`.
static QOlmExpected<QOlmOutboundGroupSessionPtr> unpickle(
- const QByteArray& pickled, const PicklingMode& mode);
+ QByteArray&& pickled, const PicklingMode& mode);
//! Encrypts a plaintext message using the session.
- QOlmExpected<QByteArray> encrypt(const QString& plaintext) const;
+ QOlmExpected<QByteArray> encrypt(const QByteArray& plaintext) const;
//! Get the current message index for this session.
//!
diff --git a/lib/e2ee/qolmsession.cpp b/lib/e2ee/qolmsession.cpp
index 771d310d..e252c37f 100644
--- a/lib/e2ee/qolmsession.cpp
+++ b/lib/e2ee/qolmsession.cpp
@@ -76,22 +76,17 @@ QOlmExpected<QOlmSessionPtr> QOlmSession::createInboundSessionFrom(
}
QOlmExpected<QOlmSessionPtr> QOlmSession::createOutboundSession(
- QOlmAccount* account, const QString& theirIdentityKey,
- const QString& theirOneTimeKey)
+ QOlmAccount* account, const QByteArray& theirIdentityKey,
+ const QByteArray& theirOneTimeKey)
{
- auto *olmOutboundSession = create();
- const auto randomLen = olm_create_outbound_session_random_length(olmOutboundSession);
- QByteArray randomBuf = getRandom(randomLen);
+ auto* olmOutboundSession = create();
+ auto randomBuf = getRandom(
+ olm_create_outbound_session_random_length(olmOutboundSession));
- QByteArray theirIdentityKeyBuf = theirIdentityKey.toUtf8();
- QByteArray theirOneTimeKeyBuf = theirOneTimeKey.toUtf8();
if (olm_create_outbound_session(
- olmOutboundSession, account->data(),
- reinterpret_cast<uint8_t*>(theirIdentityKeyBuf.data()),
- theirIdentityKeyBuf.length(),
- reinterpret_cast<uint8_t*>(theirOneTimeKeyBuf.data()),
- theirOneTimeKeyBuf.length(),
- reinterpret_cast<uint8_t*>(randomBuf.data()), randomBuf.length())
+ olmOutboundSession, account->data(), theirIdentityKey.data(),
+ theirIdentityKey.length(), theirOneTimeKey.data(),
+ theirOneTimeKey.length(), randomBuf.data(), randomBuf.length())
== olm_error()) {
// FIXME: the QOlmSession object should be created earlier
const auto lastErr = olm_session_last_error_code(olmOutboundSession);
@@ -107,7 +102,7 @@ QOlmExpected<QOlmSessionPtr> QOlmSession::createOutboundSession(
QOlmExpected<QByteArray> QOlmSession::pickle(const PicklingMode &mode) const
{
- QByteArray pickledBuf(olm_pickle_session_length(m_session), '0');
+ QByteArray pickledBuf(olm_pickle_session_length(m_session), '\0');
QByteArray key = toKey(mode);
if (olm_pickle_session(m_session, key.data(), key.length(),
pickledBuf.data(), pickledBuf.length())
@@ -118,14 +113,13 @@ QOlmExpected<QByteArray> QOlmSession::pickle(const PicklingMode &mode) const
return pickledBuf;
}
-QOlmExpected<QOlmSessionPtr> QOlmSession::unpickle(const QByteArray& pickled,
+QOlmExpected<QOlmSessionPtr> QOlmSession::unpickle(QByteArray&& pickled,
const PicklingMode& mode)
{
- QByteArray pickledBuf = pickled;
auto *olmSession = create();
- QByteArray key = toKey(mode);
+ auto key = toKey(mode);
if (olm_unpickle_session(olmSession, key.data(), key.length(),
- pickledBuf.data(), pickledBuf.length())
+ pickled.data(), pickled.length())
== olm_error()) {
// FIXME: the QOlmSession object should be created earlier
return olm_session_last_error_code(olmSession);
@@ -135,52 +129,48 @@ QOlmExpected<QOlmSessionPtr> QOlmSession::unpickle(const QByteArray& pickled,
return std::make_unique<QOlmSession>(olmSession);
}
-QOlmMessage QOlmSession::encrypt(const QString &plaintext)
+QOlmMessage QOlmSession::encrypt(const QByteArray& plaintext)
{
- QByteArray plaintextBuf = plaintext.toUtf8();
- const auto messageMaxLen = olm_encrypt_message_length(m_session, plaintextBuf.length());
- QByteArray messageBuf(messageMaxLen, '0');
- const auto messageType = encryptMessageType();
- const auto randomLen = olm_encrypt_random_length(m_session);
- QByteArray randomBuf = getRandom(randomLen);
- if (olm_encrypt(m_session, reinterpret_cast<uint8_t*>(plaintextBuf.data()),
- plaintextBuf.length(),
- reinterpret_cast<uint8_t*>(randomBuf.data()),
- randomBuf.length(),
- reinterpret_cast<uint8_t*>(messageBuf.data()),
+ const auto messageMaxLength =
+ olm_encrypt_message_length(m_session, plaintext.length());
+ QByteArray messageBuf(messageMaxLength, '0');
+ // NB: The type has to be calculated before calling olm_encrypt()
+ const auto messageType = olm_encrypt_message_type(m_session);
+ auto randomBuf = getRandom(olm_encrypt_random_length(m_session));
+ if (olm_encrypt(m_session, plaintext.data(), plaintext.length(),
+ randomBuf.data(), randomBuf.length(), messageBuf.data(),
messageBuf.length())
== olm_error()) {
throw lastError();
}
- return QOlmMessage(messageBuf, messageType);
+ randomBuf.clear();
+ return QOlmMessage(messageBuf, QOlmMessage::Type(messageType));
}
QOlmExpected<QByteArray> QOlmSession::decrypt(const QOlmMessage &message) const
{
- const auto messageType = message.type();
const auto ciphertext = message.toCiphertext();
- const auto messageTypeValue = messageType == QOlmMessage::Type::General
- ? OLM_MESSAGE_TYPE_MESSAGE : OLM_MESSAGE_TYPE_PRE_KEY;
+ const auto messageTypeValue = message.type();
// We need to clone the message because
// olm_decrypt_max_plaintext_length destroys the input buffer
- QByteArray messageBuf(ciphertext.length(), '0');
+ QByteArray messageBuf(ciphertext.length(), '\0');
std::copy(message.begin(), message.end(), messageBuf.begin());
- const auto plaintextMaxLen = olm_decrypt_max_plaintext_length(m_session, messageTypeValue,
- reinterpret_cast<uint8_t *>(messageBuf.data()), messageBuf.length());
+ const auto plaintextMaxLen = olm_decrypt_max_plaintext_length(
+ m_session, messageTypeValue, messageBuf.data(), messageBuf.length());
if (plaintextMaxLen == olm_error()) {
return lastError();
}
- QByteArray plaintextBuf(plaintextMaxLen, '0');
- QByteArray messageBuf2(ciphertext.length(), '0');
+ QByteArray plaintextBuf(plaintextMaxLen, '\0');
+ QByteArray messageBuf2(ciphertext.length(), '\0');
std::copy(message.begin(), message.end(), messageBuf2.begin());
- const auto plaintextResultLen = olm_decrypt(m_session, messageTypeValue,
- reinterpret_cast<uint8_t *>(messageBuf2.data()), messageBuf2.length(),
- reinterpret_cast<uint8_t *>(plaintextBuf.data()), plaintextMaxLen);
+ const auto plaintextResultLen =
+ olm_decrypt(m_session, messageTypeValue, messageBuf2.data(),
+ messageBuf2.length(), plaintextBuf.data(), plaintextMaxLen);
if (plaintextResultLen == olm_error()) {
const auto lastErr = lastErrorCode();
if (lastErr == OLM_OUTPUT_BUFFER_TOO_SMALL) {
@@ -188,31 +178,15 @@ QOlmExpected<QByteArray> QOlmSession::decrypt(const QOlmMessage &message) const
}
return lastErr;
}
- QByteArray output(plaintextResultLen, '0');
- std::memcpy(output.data(), plaintextBuf.data(), plaintextResultLen);
- plaintextBuf.clear();
- return output;
-}
-
-QOlmMessage::Type QOlmSession::encryptMessageType()
-{
- const auto messageTypeResult = olm_encrypt_message_type(m_session);
- if (messageTypeResult == olm_error()) {
- throw lastError();
- }
- if (messageTypeResult == OLM_MESSAGE_TYPE_PRE_KEY) {
- return QOlmMessage::PreKey;
- }
- return QOlmMessage::General;
+ plaintextBuf.truncate(plaintextResultLen);
+ return plaintextBuf;
}
QByteArray QOlmSession::sessionId() const
{
const auto idMaxLength = olm_session_id_length(m_session);
QByteArray idBuffer(idMaxLength, '0');
- if (olm_session_id(m_session, reinterpret_cast<uint8_t*>(idBuffer.data()),
- idBuffer.length())
- == olm_error()) {
+ if (olm_session_id(m_session, idBuffer.data(), idMaxLength) == olm_error()) {
throw lastError();
}
return idBuffer;
diff --git a/lib/e2ee/qolmsession.h b/lib/e2ee/qolmsession.h
index cc988a03..174e98ef 100644
--- a/lib/e2ee/qolmsession.h
+++ b/lib/e2ee/qolmsession.h
@@ -26,18 +26,18 @@ public:
const QOlmMessage& preKeyMessage);
static QOlmExpected<QOlmSessionPtr> createOutboundSession(
- QOlmAccount* account, const QString& theirIdentityKey,
- const QString& theirOneTimeKey);
+ QOlmAccount* account, const QByteArray& theirIdentityKey,
+ const QByteArray& theirOneTimeKey);
//! Serialises an `QOlmSession` to encrypted Base64.
QOlmExpected<QByteArray> pickle(const PicklingMode &mode) const;
- //! Deserialises from encrypted Base64 that was previously obtained by pickling a `QOlmSession`.
- static QOlmExpected<QOlmSessionPtr> unpickle(
- const QByteArray& pickled, const PicklingMode& mode);
+ //! Deserialises from encrypted Base64 previously made with pickle()
+ static QOlmExpected<QOlmSessionPtr> unpickle(QByteArray&& pickled,
+ const PicklingMode& mode);
//! Encrypts a plaintext message using the session.
- QOlmMessage encrypt(const QString &plaintext);
+ QOlmMessage encrypt(const QByteArray& plaintext);
//! Decrypts a message using this session. Decoding is lossy, meaning if
//! the decrypted plaintext contains invalid UTF-8 symbols, they will
@@ -47,9 +47,6 @@ public:
//! Get a base64-encoded identifier for this session.
QByteArray sessionId() const;
- //! The type of the next message that will be returned from encryption.
- QOlmMessage::Type encryptMessageType();
-
//! Checker for any received messages for this session.
bool hasReceivedMessage() const;
diff --git a/lib/e2ee/qolmutility.cpp b/lib/e2ee/qolmutility.cpp
index 15c875c0..08c2b699 100644
--- a/lib/e2ee/qolmutility.cpp
+++ b/lib/e2ee/qolmutility.cpp
@@ -32,7 +32,7 @@ QOlmUtility::~QOlmUtility()
QString QOlmUtility::sha256Bytes(const QByteArray &inputBuf) const
{
const auto outputLen = olm_sha256_length(m_utility);
- QByteArray outputBuf(outputLen, '0');
+ QByteArray outputBuf(outputLen, '\0');
olm_sha256(m_utility, inputBuf.data(), inputBuf.length(),
outputBuf.data(), outputBuf.length());
@@ -48,19 +48,17 @@ QOlmExpected<bool> QOlmUtility::ed25519Verify(const QByteArray& key,
const QByteArray& message,
const QByteArray& signature)
{
- QByteArray signatureBuf(signature.length(), '0');
+ QByteArray signatureBuf(signature.length(), '\0');
std::copy(signature.begin(), signature.end(), signatureBuf.begin());
- const auto ret = olm_ed25519_verify(m_utility, key.data(), key.size(),
- message.data(), message.size(),
- (void*)signatureBuf.data(),
- signatureBuf.size());
- if (ret == olm_error()) {
- auto error = lastErrorCode();
- if (error == OLM_BAD_MESSAGE_MAC)
- return false;
- return error;
- }
+ if (olm_ed25519_verify(m_utility, key.data(), key.size(), message.data(),
+ message.size(), signatureBuf.data(),
+ signatureBuf.size())
+ == 0)
+ return true;
- return ret == 0;
+ auto error = lastErrorCode();
+ if (error == OLM_BAD_MESSAGE_MAC)
+ return false;
+ return error;
}
diff --git a/lib/e2ee/qolmutils.h b/lib/e2ee/qolmutils.h
index f218e628..7a8511c3 100644
--- a/lib/e2ee/qolmutils.h
+++ b/lib/e2ee/qolmutils.h
@@ -9,6 +9,7 @@
#include "e2ee/e2ee.h"
namespace Quotient {
+
// Convert PicklingMode to key
QUOTIENT_API QByteArray toKey(const PicklingMode &mode);
QUOTIENT_API QByteArray getRandom(size_t bufferSize);
diff --git a/lib/events/filesourceinfo.cpp b/lib/events/filesourceinfo.cpp
index e8b6794b..6abe6a08 100644
--- a/lib/events/filesourceinfo.cpp
+++ b/lib/events/filesourceinfo.cpp
@@ -59,19 +59,15 @@ std::pair<EncryptedFileMetadata, QByteArray> Quotient::encryptFile(
const QByteArray& plainText)
{
#ifdef Quotient_E2EE_ENABLED
- QByteArray k = getRandom(32);
- auto kBase64 = k.toBase64();
- QByteArray iv = getRandom(16);
- JWK key = { "oct"_ls,
- { "encrypt"_ls, "decrypt"_ls },
- "A256CTR"_ls,
- QString(k.toBase64())
- .replace(u'/', u'_')
- .replace(u'+', u'-')
- .left(kBase64.indexOf('=')),
- true };
-
- int length;
+ auto k = getRandom(32);
+ auto kBase64 = k.toBase64(QByteArray::Base64UrlEncoding
+ | QByteArray::OmitTrailingEquals);
+ auto iv = getRandom(16);
+ JWK key = {
+ "oct"_ls, { "encrypt"_ls, "decrypt"_ls }, "A256CTR"_ls, kBase64, true
+ };
+
+ int length = -1;
auto* ctx = EVP_CIPHER_CTX_new();
EVP_EncryptInit_ex(ctx, EVP_aes_256_ctr(), nullptr,
reinterpret_cast<const unsigned char*>(k.data()),
@@ -89,14 +85,11 @@ std::pair<EncryptedFileMetadata, QByteArray> Quotient::encryptFile(
EVP_CIPHER_CTX_free(ctx);
auto hash = QCryptographicHash::hash(cipherText, QCryptographicHash::Sha256)
- .toBase64();
- auto ivBase64 = iv.toBase64();
- EncryptedFileMetadata efm = { {},
- key,
- ivBase64.left(ivBase64.indexOf('=')),
- { { QStringLiteral("sha256"),
- hash.left(hash.indexOf('=')) } },
- "v2"_ls };
+ .toBase64(QByteArray::OmitTrailingEquals);
+ auto ivBase64 = iv.toBase64(QByteArray::OmitTrailingEquals);
+ EncryptedFileMetadata efm = {
+ {}, key, ivBase64, { { QStringLiteral("sha256"), hash } }, "v2"_ls
+ };
return { efm, cipherText };
#else
return {};
diff --git a/lib/keyverificationsession.cpp b/lib/keyverificationsession.cpp
index 3f76eac1..0f24c743 100644
--- a/lib/keyverificationsession.cpp
+++ b/lib/keyverificationsession.cpp
@@ -71,9 +71,9 @@ void KeyVerificationSession::init(milliseconds timeout)
QTimer::singleShot(timeout, this, [this] { cancelVerification(TIMEOUT); });
m_sas = olm_sas(new std::byte[olm_sas_size()]);
- auto randomSize = olm_create_sas_random_length(m_sas);
- auto random = getRandom(randomSize);
- olm_create_sas(m_sas, random.data(), randomSize);
+ const auto randomLength = olm_create_sas_random_length(m_sas);
+ auto random = getRandom(randomLength);
+ olm_create_sas(m_sas, random.data(), randomLength);
}
KeyVerificationSession::~KeyVerificationSession()
--
cgit v1.2.3