diff --git a/src/browser/BrowserHost.cpp b/src/browser/BrowserHost.cpp index bc6129bf1..493b7f609 100644 --- a/src/browser/BrowserHost.cpp +++ b/src/browser/BrowserHost.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2020 KeePassXC Team + * Copyright (C) 2026 KeePassXC Team * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -69,31 +69,29 @@ void BrowserHost::proxyConnected() void BrowserHost::readProxyMessage() { - QLocalSocket* socket = qobject_cast(QObject::sender()); + auto* socket = qobject_cast(QObject::sender()); if (!socket || socket->bytesAvailable() <= 0) { return; } - socket->setReadBufferSize(BrowserShared::NATIVEMSG_MAX_LENGTH); + socket->setReadBufferSize(BrowserShared::SOCKET_BUFFER_SIZE); int socketDesc = socket->socketDescriptor(); if (socketDesc) { - int max = BrowserShared::NATIVEMSG_MAX_LENGTH; + int max = BrowserShared::SOCKET_BUFFER_SIZE; setsockopt(socketDesc, SOL_SOCKET, SO_SNDBUF, reinterpret_cast(&max), sizeof(max)); } - QJsonParseError error; - auto json = QJsonDocument::fromJson(socket->readAll(), &error); - if (json.isNull()) { - qWarning() << "Failed to read proxy message: " << error.errorString(); - return; + const auto messages = parseSocketData(socket->readAll(), socketDesc); + for (const auto& message : messages) { + if (!message.isEmpty()) { + emit clientMessageReceived(socket, message); + } } - - emit clientMessageReceived(socket, json.object()); } void BrowserHost::broadcastClientMessage(const QJsonObject& json) { - QString reply(QJsonDocument(json).toJson(QJsonDocument::Compact)); + const auto reply(QJsonDocument(json).toJson(QJsonDocument::Compact)); for (const auto socket : m_socketList) { sendClientData(socket, reply); } @@ -101,19 +99,122 @@ void BrowserHost::broadcastClientMessage(const QJsonObject& json) void BrowserHost::sendClientMessage(QLocalSocket* socket, const QJsonObject& json) { - QString reply(QJsonDocument(json).toJson(QJsonDocument::Compact)); + const auto reply(QJsonDocument(json).toJson(QJsonDocument::Compact)); sendClientData(socket, reply); } void BrowserHost::sendClientData(QLocalSocket* socket, const QString& data) { if (socket && socket->isValid() && socket->state() == QLocalSocket::ConnectedState) { - QByteArray arr = data.toUtf8(); + const auto arr = data.toUtf8(); socket->write(arr.constData(), arr.length()); socket->flush(); } } +// Parses coalesced messages +QList +BrowserHost::parseSocketData(const QByteArray& socketData, const int socketDesc, const qsizetype maxLength) +{ + QList messages; + + // Split, and put } back to the messages + auto splittedSocketData = socketData.split('}'); + for (auto i = 0; i < splittedSocketData.size() - 1; ++i) { + splittedSocketData[i].append('}'); + } + + for (const auto& data : splittedSocketData) { + if (data.length() > 0) { + const auto parsedMessage = parseMessage(data, socketDesc, maxLength); + if (!parsedMessage.isEmpty()) { + messages << parsedMessage; + } + } + } + + return messages; +} + +// Parses fragmented messages, or messages with garbage data +// The JSON data recevied is always just one object with keys & values. No nested objects, arrays etc. are present. +// Coalesced messages rely entirely on that message format. +QJsonObject BrowserHost::parseMessage(const QByteArray& socketData, const int socketDesc, const qsizetype maxLength) +{ + if (socketData.isEmpty()) { + return {}; + } + + // Ignore any garbage at the beginning and try to find the position where JSON data starts + auto startPos = socketData.indexOf('{'); + if (startPos < 0) { + // Allow -1 because message can be fragmented. Set startPos back to 0. + startPos = 0; + } + + const auto message = socketData.mid(startPos); + QJsonParseError error; + auto json = QJsonDocument::fromJson(message, &error); + if (json.isNull()) { + qWarning() << "Failed to read proxy message: " << error.error << error.errorString(); + + // First fragmented message is of these errors. Partial message must be stored to a temporary buffer. + if (error.error == QJsonParseError::UnterminatedObject || error.error == QJsonParseError::UnterminatedArray + || error.error == QJsonParseError::UnterminatedString) { + m_messageBuffer.insert(socketDesc, message); + return {}; + } + + // Nth fragmented message can be an illegal value or illegal number + if (error.error == QJsonParseError::IllegalValue || error.error == QJsonParseError::IllegalNumber) { + return parseFragmentedMessage(message, socketDesc, maxLength); + } + + // This error can happen with two different scenarios: + // 1. Identifies a non-fragmented message with garbage at the end. + // 2. Identifies a fragmented message and passes it forward. + if (error.error == QJsonParseError::GarbageAtEnd && error.offset > 0) { + // Parse message before the error offset and parse the JSON again + const auto parsedMessage = message.left(error.offset); + if (parsedMessage.startsWith('{')) { + json = QJsonDocument::fromJson(parsedMessage, &error); + if (!json.isNull() && error.error == QJsonParseError::NoError) { + m_messageBuffer.remove(socketDesc); + return json.object(); + } + } else { + return parseFragmentedMessage(message, socketDesc, maxLength); + } + } + } else { + m_messageBuffer.remove(socketDesc); + return json.object(); + } + + return {}; +} + +// Returns the previous message(s) from the buffer, combines them with the current one, and parses again +QJsonObject +BrowserHost::parseFragmentedMessage(const QByteArray& message, const int socketDesc, const qsizetype maxLength) +{ + auto currentBuffer = m_messageBuffer.value(socketDesc); + if (currentBuffer.length() == 0) { + qWarning() << "Previous buffer not found."; + m_messageBuffer.remove(socketDesc); + return {}; + } + + if (currentBuffer.length() + message.length() > maxLength) { + qWarning() << "Combined fragmented messages exceeded the maximum allowed length."; + m_messageBuffer.remove(socketDesc); + return {}; + } + + currentBuffer.append(message); + return parseMessage(currentBuffer, socketDesc, maxLength); +} + void BrowserHost::proxyDisconnected() { auto socket = qobject_cast(QObject::sender()); diff --git a/src/browser/BrowserHost.h b/src/browser/BrowserHost.h index f3620c04c..366fdb7d2 100644 --- a/src/browser/BrowserHost.h +++ b/src/browser/BrowserHost.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2020 KeePassXC Team + * Copyright (C) 2026 KeePassXC Team * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -15,10 +15,13 @@ * along with this program. If not, see . */ -#ifndef KEEPASSXC_NATIVEMESSAGINGHOST_H -#define KEEPASSXC_NATIVEMESSAGINGHOST_H +#ifndef KEEPASSXC_BROWSERHOST_H +#define KEEPASSXC_BROWSERHOST_H + +#include "BrowserShared.h" #include +#include #include #include @@ -50,10 +53,22 @@ private slots: private: void sendClientData(QLocalSocket* socket, const QString& data); + QList parseSocketData(const QByteArray& socketData, + const int socketDesc, + const qsizetype maxLength = BrowserShared::SOCKET_BUFFER_SIZE); + QJsonObject parseMessage(const QByteArray& socketData, + const int socketDesc, + const qsizetype maxLength = BrowserShared::SOCKET_BUFFER_SIZE); + QJsonObject parseFragmentedMessage(const QByteArray& message, + const int socketDesc, + const qsizetype maxLength = BrowserShared::SOCKET_BUFFER_SIZE); private: QPointer m_localServer; QList m_socketList; + QMap m_messageBuffer; + + friend class TestBrowser; }; -#endif // KEEPASSXC_NATIVEMESSAGINGHOST_H +#endif // KEEPASSXC_BROWSERHOST_H diff --git a/src/browser/BrowserMessageBuilder.cpp b/src/browser/BrowserMessageBuilder.cpp index 12318fadb..e8a9b831c 100644 --- a/src/browser/BrowserMessageBuilder.cpp +++ b/src/browser/BrowserMessageBuilder.cpp @@ -28,10 +28,6 @@ #include #endif -#include - -using namespace Botan::Sodium; - Q_GLOBAL_STATIC(BrowserMessageBuilder, s_browserMessageBuilder); BrowserMessageBuilder* BrowserMessageBuilder::instance() @@ -166,15 +162,17 @@ QString BrowserMessageBuilder::getErrorMessage(const int errorCode) const QString BrowserMessageBuilder::encryptMessage(const QJsonObject& message, const QString& nonce, const QString& publicKey, - const QString& secretKey) + const QString& secretKey, + const qsizetype maxLength, + const qsizetype macBytes) { if (message.isEmpty() || nonce.isEmpty()) { return {}; } - const QString reply(QJsonDocument(message).toJson()); + const auto reply(QJsonDocument(message).toJson()); if (!reply.isEmpty()) { - return encrypt(reply, nonce, publicKey, secretKey); + return encrypt(reply, nonce, publicKey, secretKey, maxLength, macBytes); } return {}; @@ -183,13 +181,15 @@ QString BrowserMessageBuilder::encryptMessage(const QJsonObject& message, QJsonObject BrowserMessageBuilder::decryptMessage(const QString& message, const QString& nonce, const QString& publicKey, - const QString& secretKey) + const QString& secretKey, + const qsizetype maxLength, + const qsizetype macBytes) { if (message.isEmpty() || nonce.isEmpty()) { return {}; } - QByteArray ba = decrypt(message, nonce, publicKey, secretKey); + const auto ba = decrypt(message, nonce, publicKey, secretKey, maxLength, macBytes); if (ba.isEmpty()) { return {}; } @@ -200,28 +200,59 @@ QJsonObject BrowserMessageBuilder::decryptMessage(const QString& message, QString BrowserMessageBuilder::encrypt(const QString& plaintext, const QString& nonce, const QString& publicKey, - const QString& secretKey) + const QString& secretKey, + const qsizetype maxLength, + const qsizetype macBytes) { - const QByteArray ma = plaintext.toUtf8(); - const QByteArray na = base64Decode(nonce); - const QByteArray ca = base64Decode(publicKey); - const QByteArray sa = base64Decode(secretKey); - - std::vector m(ma.cbegin(), ma.cend()); - std::vector n(na.cbegin(), na.cend()); - std::vector ck(ca.cbegin(), ca.cend()); - std::vector sk(sa.cbegin(), sa.cend()); - - std::vector e; - e.resize(BrowserShared::NATIVEMSG_MAX_LENGTH); - - if (m.empty() || n.empty() || ck.empty() || sk.empty()) { + const QByteArray messageBytes = plaintext.toUtf8(); + if (messageBytes.length() > maxLength) { + qWarning() << "Message length" << messageBytes.length() << "exceeds the maximum size."; return {}; } - if (crypto_box_easy(e.data(), m.data(), m.size(), n.data(), ck.data(), sk.data()) == 0) { - QByteArray res = getQByteArray(e.data(), (crypto_box_MACBYTES + ma.length())); - return res.toBase64(); + const QByteArray nonceBytes = base64Decode(nonce); + if (nonceBytes.length() != crypto_box_NONCEBYTES) { + qWarning() << "Nonce length" << nonceBytes.length() << "is invalid."; + return {}; + } + + const QByteArray publicKeyBytes = base64Decode(publicKey); + if (publicKeyBytes.length() != crypto_box_PUBLICKEYBYTES) { + qWarning() << "Public key length" << publicKeyBytes.length() << "is invalid."; + return {}; + } + + const QByteArray secretKeyBytes = base64Decode(secretKey); + if (secretKeyBytes.length() != crypto_box_SECRETKEYBYTES) { + qWarning() << "Secret key length" << secretKeyBytes.length() << "is invalid."; + return {}; + } + + const std::vector messageVec(messageBytes.cbegin(), messageBytes.cend()); + const std::vector nonceVec(nonceBytes.cbegin(), nonceBytes.cend()); + const std::vector publicKeyVec(publicKeyBytes.cbegin(), publicKeyBytes.cend()); + const std::vector secretKeyVec(secretKeyBytes.cbegin(), secretKeyBytes.cend()); + if (messageVec.empty() || nonceVec.empty() || publicKeyVec.empty() || secretKeyVec.empty()) { + return {}; + } + + std::vector encryptedData; + encryptedData.resize(maxLength + macBytes); + + if (crypto_box_easy(encryptedData.data(), + messageVec.data(), + messageVec.size(), + nonceVec.data(), + publicKeyVec.data(), + secretKeyVec.data()) + == 0) { + const auto res = getQByteArray(encryptedData.data(), (macBytes + messageBytes.length())); + const auto resBase64 = res.toBase64(); + if (resBase64.length() > BrowserShared::SOCKET_BUFFER_SIZE) { + qWarning() << "Encoded message length" << resBase64.length() << "exceeds the maximum socket buffer size."; + return {}; + } + return resBase64; } return {}; @@ -230,27 +261,60 @@ QString BrowserMessageBuilder::encrypt(const QString& plaintext, QByteArray BrowserMessageBuilder::decrypt(const QString& encrypted, const QString& nonce, const QString& publicKey, - const QString& secretKey) + const QString& secretKey, + const qsizetype maxLength, + const qsizetype macBytes) { - const QByteArray ma = base64Decode(encrypted); - const QByteArray na = base64Decode(nonce); - const QByteArray ca = base64Decode(publicKey); - const QByteArray sa = base64Decode(secretKey); - - std::vector m(ma.cbegin(), ma.cend()); - std::vector n(na.cbegin(), na.cend()); - std::vector ck(ca.cbegin(), ca.cend()); - std::vector sk(sa.cbegin(), sa.cend()); - - std::vector d; - d.resize(BrowserShared::NATIVEMSG_MAX_LENGTH); - - if (m.empty() || n.empty() || ck.empty() || sk.empty()) { + const QByteArray encryptedBytes = base64Decode(encrypted); + if (encryptedBytes.size() == 0 && encrypted.size() > 0) { + qWarning() << "Message is not a valid base64 encoded string."; + } + if (maxLength < 0 || encryptedBytes.size() < macBytes) { + qWarning() << "Message length" << encryptedBytes.length() << "is smaller than required."; + return {}; + } + if (encryptedBytes.size() - macBytes > maxLength) { + qWarning() << "Message length" << encryptedBytes.length() << "exceeds the maximum size."; return {}; } - if (crypto_box_open_easy(d.data(), m.data(), ma.length(), n.data(), ck.data(), sk.data()) == 0) { - return getQByteArray(d.data(), std::char_traits::length(reinterpret_cast(d.data()))); + const QByteArray nonceBytes = base64Decode(nonce); + if (nonceBytes.length() != crypto_box_NONCEBYTES) { + qWarning() << "Nonce length" << nonceBytes.length() << "is invalid."; + return {}; + } + + const QByteArray publicKeyBytes = base64Decode(publicKey); + if (publicKeyBytes.length() != crypto_box_PUBLICKEYBYTES) { + qWarning() << "Public key length" << publicKeyBytes.length() << "is invalid."; + return {}; + } + + const QByteArray secretKeyBytes = base64Decode(secretKey); + if (secretKeyBytes.length() != crypto_box_SECRETKEYBYTES) { + qWarning() << "Secret key length" << secretKeyBytes.length() << "is invalid."; + return {}; + } + + const std::vector encryptedVec(encryptedBytes.cbegin(), encryptedBytes.cend()); + const std::vector nonceVec(nonceBytes.cbegin(), nonceBytes.cend()); + const std::vector publicKeyVec(publicKeyBytes.cbegin(), publicKeyBytes.cend()); + const std::vector secretKeyVec(secretKeyBytes.cbegin(), secretKeyBytes.cend()); + if (encryptedVec.empty() || nonceVec.empty() || publicKeyVec.empty() || secretKeyVec.empty()) { + return {}; + } + + std::vector decryptedData; + decryptedData.resize(encryptedVec.size() - macBytes); + + if (crypto_box_open_easy(decryptedData.data(), + encryptedVec.data(), + encryptedBytes.length(), + nonceVec.data(), + publicKeyVec.data(), + secretKeyVec.data()) + == 0) { + return getQByteArray(decryptedData.data(), decryptedData.size()); } return {}; @@ -299,12 +363,18 @@ QJsonObject BrowserMessageBuilder::getJsonObject(const QByteArray& ba) const QByteArray BrowserMessageBuilder::base64Decode(const QString& str) { - return QByteArray::fromBase64(str.toUtf8()); + // Returns an empty QByteArray if the string is not valid base64 + return QByteArray::fromBase64(str.toUtf8(), QByteArray::AbortOnBase64DecodingErrors); } QString BrowserMessageBuilder::incrementNonce(const QString& nonce) { const QByteArray nonceArray = base64Decode(nonce); + if (nonceArray.length() != crypto_box_NONCEBYTES) { + qWarning() << "Nonce length" << nonceArray.length() << "is invalid."; + return {}; + } + std::vector n(nonceArray.cbegin(), nonceArray.cend()); sodium_increment(n.data(), n.size()); diff --git a/src/browser/BrowserMessageBuilder.h b/src/browser/BrowserMessageBuilder.h index c4743bc93..b6db05d58 100644 --- a/src/browser/BrowserMessageBuilder.h +++ b/src/browser/BrowserMessageBuilder.h @@ -18,10 +18,18 @@ #ifndef KEEPASSXC_BROWSERMESSAGEBUILDER_H #define KEEPASSXC_BROWSERMESSAGEBUILDER_H +#include "BrowserShared.h" + #include #include #include +#include + +using namespace Botan::Sodium; + +constexpr auto MacBytes = static_cast(crypto_box_MACBYTES); + class QJsonObject; typedef QMap Parameters; @@ -86,12 +94,27 @@ public: QString encryptMessage(const QJsonObject& message, const QString& nonce, const QString& publicKey, - const QString& secretKey); - QJsonObject - decryptMessage(const QString& message, const QString& nonce, const QString& publicKey, const QString& secretKey); - QString encrypt(const QString& plaintext, const QString& nonce, const QString& publicKey, const QString& secretKey); - QByteArray - decrypt(const QString& encrypted, const QString& nonce, const QString& publicKey, const QString& secretKey); + const QString& secretKey, + const qsizetype maxLength = BrowserShared::NATIVEMSG_MAX_LENGTH, + const qsizetype macBytes = MacBytes); + QJsonObject decryptMessage(const QString& message, + const QString& nonce, + const QString& publicKey, + const QString& secretKey, + const qsizetype maxLength = BrowserShared::NATIVEMSG_MAX_LENGTH, + const qsizetype macBytes = MacBytes); + QString encrypt(const QString& plaintext, + const QString& nonce, + const QString& publicKey, + const QString& secretKey, + const qsizetype maxLength = BrowserShared::NATIVEMSG_MAX_LENGTH, + const qsizetype macBytes = MacBytes); + QByteArray decrypt(const QString& encrypted, + const QString& nonce, + const QString& publicKey, + const QString& secretKey, + const qsizetype maxLength = BrowserShared::NATIVEMSG_MAX_LENGTH, + const qsizetype macBytes = MacBytes); QString getBase64FromKey(const uchar* array, const uint len); QByteArray getQByteArray(const uchar* array, const uint len) const; diff --git a/src/browser/BrowserShared.h b/src/browser/BrowserShared.h index 853ddea1c..a4080b098 100644 --- a/src/browser/BrowserShared.h +++ b/src/browser/BrowserShared.h @@ -22,7 +22,8 @@ namespace BrowserShared { - constexpr int NATIVEMSG_MAX_LENGTH = 1024 * 1024; + constexpr int SOCKET_BUFFER_SIZE = 1024 * 1024; + constexpr int NATIVEMSG_MAX_LENGTH = SOCKET_BUFFER_SIZE / 1.6; // 655 360 enum SupportedBrowsers : int { diff --git a/src/proxy/NativeMessagingProxy.cpp b/src/proxy/NativeMessagingProxy.cpp index 93f2c48dc..b545e70f5 100644 --- a/src/proxy/NativeMessagingProxy.cpp +++ b/src/proxy/NativeMessagingProxy.cpp @@ -93,10 +93,10 @@ void NativeMessagingProxy::setupLocalSocket() { m_localSocket.reset(new QLocalSocket()); m_localSocket->connectToServer(BrowserShared::localServerPath()); - m_localSocket->setReadBufferSize(BrowserShared::NATIVEMSG_MAX_LENGTH); + m_localSocket->setReadBufferSize(BrowserShared::SOCKET_BUFFER_SIZE); int socketDesc = m_localSocket->socketDescriptor(); if (socketDesc) { - int max = BrowserShared::NATIVEMSG_MAX_LENGTH; + int max = BrowserShared::SOCKET_BUFFER_SIZE; setsockopt(socketDesc, SOL_SOCKET, SO_SNDBUF, reinterpret_cast(&max), sizeof(max)); } diff --git a/tests/TestBrowser.cpp b/tests/TestBrowser.cpp index cbd875767..15afa2b80 100644 --- a/tests/TestBrowser.cpp +++ b/tests/TestBrowser.cpp @@ -17,6 +17,7 @@ #include "TestBrowser.h" +#include "browser/BrowserHost.h" #include "browser/BrowserMessageBuilder.h" #include "browser/BrowserSettings.h" #include "core/Group.h" @@ -74,24 +75,145 @@ void TestBrowser::testEncryptMessage() { QJsonObject message; message["action"] = "test-action"; + const int messageSize = 32; + QString invalidKey = "dGVzdHN0cmluZw=="; m_browserAction->m_publicKey = SERVERPUBLICKEY; m_browserAction->m_secretKey = SERVERSECRETKEY; m_browserAction->m_clientPublicKey = PUBLICKEY; - auto encrypted = browserMessageBuilder()->encryptMessage(message, NONCE, PUBLICKEY, SERVERSECRETKEY); + // Public key length is not valid + auto encrypted = browserMessageBuilder()->encryptMessage(message, NONCE, invalidKey, SERVERSECRETKEY); + QVERIFY(encrypted.isEmpty()); + + // Secret key length is not valid + encrypted = browserMessageBuilder()->encryptMessage(message, NONCE, PUBLICKEY, invalidKey); + QVERIFY(encrypted.isEmpty()); + + // Nonce length is not valid + encrypted = browserMessageBuilder()->encryptMessage(message, invalidKey, PUBLICKEY, SERVERSECRETKEY); + QVERIFY(encrypted.isEmpty()); + + // Max message length is exceeded (set to 20) + encrypted = browserMessageBuilder()->encryptMessage(message, NONCE, PUBLICKEY, SERVERSECRETKEY, 20); + QVERIFY(encrypted.isEmpty()); + + // Empty message + encrypted = browserMessageBuilder()->encryptMessage(QJsonObject(), NONCE, PUBLICKEY, SERVERSECRETKEY); + QVERIFY(encrypted.isEmpty()); + + // Successful encryption, the message itself is 32 bytes + encrypted = browserMessageBuilder()->encryptMessage(message, NONCE, PUBLICKEY, SERVERSECRETKEY); QCOMPARE(encrypted, QString("+zjtntnk4rGWSl/Ph7Vqip/swvgeupk4lNgHEm2OO3ujNr0OMz6eQtGwjtsj+/rP")); + + // Test boundaries (-1, exact length, +1) + encrypted = browserMessageBuilder()->encryptMessage(message, NONCE, PUBLICKEY, SERVERSECRETKEY, messageSize - 1); + QVERIFY(encrypted.isEmpty()); // Exceeds + encrypted = browserMessageBuilder()->encryptMessage(message, NONCE, PUBLICKEY, SERVERSECRETKEY, messageSize); + QCOMPARE(encrypted, QString("+zjtntnk4rGWSl/Ph7Vqip/swvgeupk4lNgHEm2OO3ujNr0OMz6eQtGwjtsj+/rP")); + encrypted = browserMessageBuilder()->encryptMessage(message, NONCE, PUBLICKEY, SERVERSECRETKEY, messageSize + 1); + QCOMPARE(encrypted, QString("+zjtntnk4rGWSl/Ph7Vqip/swvgeupk4lNgHEm2OO3ujNr0OMz6eQtGwjtsj+/rP")); + + // Test the same boundaries with MACBYTES-1 + encrypted = browserMessageBuilder()->encryptMessage( + message, NONCE, PUBLICKEY, SERVERSECRETKEY, messageSize - 1, MacBytes - 1); + QVERIFY(encrypted.isEmpty()); // Exceeds + encrypted = + browserMessageBuilder()->encryptMessage(message, NONCE, PUBLICKEY, SERVERSECRETKEY, messageSize, MacBytes - 1); + QCOMPARE(encrypted, QString("+zjtntnk4rGWSl/Ph7Vqip/swvgeupk4lNgHEm2OO3ujNr0OMz6eQtGwjtsj+/o=")); + encrypted = browserMessageBuilder()->encryptMessage( + message, NONCE, PUBLICKEY, SERVERSECRETKEY, messageSize + 1, MacBytes - 1); + QCOMPARE(encrypted, QString("+zjtntnk4rGWSl/Ph7Vqip/swvgeupk4lNgHEm2OO3ujNr0OMz6eQtGwjtsj+/o=")); + + // Test the same boundaries with MACBYTES+1 + encrypted = browserMessageBuilder()->encryptMessage( + message, NONCE, PUBLICKEY, SERVERSECRETKEY, messageSize - 1, MacBytes + 1); + QVERIFY(encrypted.isEmpty()); // Exceeds + encrypted = + browserMessageBuilder()->encryptMessage(message, NONCE, PUBLICKEY, SERVERSECRETKEY, messageSize, MacBytes + 1); + QCOMPARE(encrypted, QString("+zjtntnk4rGWSl/Ph7Vqip/swvgeupk4lNgHEm2OO3ujNr0OMz6eQtGwjtsj+/rPAA==")); + encrypted = browserMessageBuilder()->encryptMessage( + message, NONCE, PUBLICKEY, SERVERSECRETKEY, messageSize + 1, MacBytes + 1); + QCOMPARE(encrypted, QString("+zjtntnk4rGWSl/Ph7Vqip/swvgeupk4lNgHEm2OO3ujNr0OMz6eQtGwjtsj+/rPAA==")); + + // Encrypt JSON with NULL character. Result will be {"action": "test"}. + message["action"] = "test\u0000-action"; + encrypted = browserMessageBuilder()->encryptMessage(message, NONCE, PUBLICKEY, SERVERSECRETKEY); + QCOMPARE(encrypted, QString("MRqyE6YAJQcytKFDkFWIF5/swvgeupk4lNgHEm2OO3ujNr0OMzH1XK8=")); } void TestBrowser::testDecryptMessage() { QString message = "+zjtntnk4rGWSl/Ph7Vqip/swvgeupk4lNgHEm2OO3ujNr0OMz6eQtGwjtsj+/rP"; + const int messageSize = 32; + QString invalidKey = "dGVzdHN0cmluZw=="; m_browserAction->m_publicKey = SERVERPUBLICKEY; m_browserAction->m_secretKey = SERVERSECRETKEY; m_browserAction->m_clientPublicKey = PUBLICKEY; - auto decrypted = browserMessageBuilder()->decryptMessage(message, NONCE, PUBLICKEY, SERVERSECRETKEY); + // Public key length is not valid + auto decrypted = browserMessageBuilder()->decryptMessage(message, NONCE, invalidKey, SERVERSECRETKEY); + QVERIFY(decrypted.isEmpty()); + + // Secret key length is not valid + decrypted = browserMessageBuilder()->decryptMessage(message, NONCE, PUBLICKEY, invalidKey); + QVERIFY(decrypted.isEmpty()); + + // Nonce length is not valid + decrypted = browserMessageBuilder()->decryptMessage(message, invalidKey, PUBLICKEY, SERVERSECRETKEY); + QVERIFY(decrypted.isEmpty()); + + // Max message length is exceeded (set to 20) + decrypted = browserMessageBuilder()->decryptMessage(message, NONCE, PUBLICKEY, SERVERSECRETKEY, 20); + QVERIFY(decrypted.isEmpty()); + + // Empty message + decrypted = browserMessageBuilder()->decryptMessage(QString(), NONCE, PUBLICKEY, SERVERSECRETKEY); + QVERIFY(decrypted.isEmpty()); + + // Successful decryption + decrypted = browserMessageBuilder()->decryptMessage(message, NONCE, PUBLICKEY, SERVERSECRETKEY); QCOMPARE(decrypted["action"].toString(), QString("test-action")); + + // Test boundaries (-1, exact length, +1) + decrypted = browserMessageBuilder()->decryptMessage(message, NONCE, PUBLICKEY, SERVERSECRETKEY, messageSize - 1); + QVERIFY(decrypted.isEmpty()); // Exceeds + decrypted = browserMessageBuilder()->decryptMessage(message, NONCE, PUBLICKEY, SERVERSECRETKEY, messageSize); + QCOMPARE(decrypted["action"].toString(), QString("test-action")); + decrypted = browserMessageBuilder()->decryptMessage(message, NONCE, PUBLICKEY, SERVERSECRETKEY, messageSize + 1); + QCOMPARE(decrypted["action"].toString(), QString("test-action")); + + // Test the same boundaries with MACBYTES-1 + for (int i = messageSize - 1; i <= messageSize + 1; ++i) { + decrypted = + browserMessageBuilder()->decryptMessage(message, NONCE, PUBLICKEY, SERVERSECRETKEY, i, MacBytes - 1); + QVERIFY(decrypted.isEmpty()); + } + + // Test the same boundaries with MACBYTES+1 + for (int i = messageSize - 1; i <= messageSize + 1; ++i) { + decrypted = + browserMessageBuilder()->decryptMessage(message, NONCE, PUBLICKEY, SERVERSECRETKEY, i, MacBytes + 1); + QCOMPARE(decrypted["action"].toString(), QString("test-action")); + } + + // Malformed base64 + decrypted = browserMessageBuilder()->decryptMessage( + QString("+zjtntnk4r3GWSl/Ph7Vqip/swvgeupk4lNgHEmA3B4ujNr0OMz6eQtGwjtsj+/rP"), + NONCE, + PUBLICKEY, + SERVERSECRETKEY); + QVERIFY(decrypted.isEmpty()); + + // Malformed data (not base64 encoded) + const auto malformed = QString("asdadfsar346fw3242eddecryptMessage(malformed, NONCE, PUBLICKEY, SERVERSECRETKEY); + QVERIFY(decrypted.isEmpty()); + + // Data had originally a value with NULL char. Encrypted value from testEncryptMessage(). + const auto jsonWithNull = QString("MRqyE6YAJQcytKFDkFWIF5/swvgeupk4lNgHEm2OO3ujNr0OMzH1XK8="); + decrypted = browserMessageBuilder()->decryptMessage(jsonWithNull, NONCE, PUBLICKEY, SERVERSECRETKEY); + QCOMPARE(decrypted["action"].toString(), QString("test")); } void TestBrowser::testGetBase64FromKey() @@ -110,6 +232,10 @@ void TestBrowser::testIncrementNonce() { auto result = browserMessageBuilder()->incrementNonce(NONCE); QCOMPARE(result, INCREMENTEDNONCE); + + const QString invalidNonce = "dGVzdHN0cmluZw=="; + result = browserMessageBuilder()->incrementNonce(invalidNonce); + QVERIFY(result.isEmpty()); } void TestBrowser::testBuildResponse() @@ -908,3 +1034,181 @@ void TestBrowser::testHideEntry() result = m_browserService->searchEntries(db, "https://github.com", "https://github.com/session"); QCOMPARE(result.length(), 1); } + +void TestBrowser::testBrowserHostMessaging() +{ + BrowserHost browserHost; + + QByteArray normalMessage(R"({"action": "test-action", "nonce": "testnonce"})"); + auto result = browserHost.parseMessage(normalMessage, 0); + QVERIFY(result.value("action") == "test-action" && result.value("nonce") == "testnonce"); + + // Not a valid JSON + QByteArray notValid("A normal string"); + result = browserHost.parseMessage(notValid, 0); + QVERIFY(result.isEmpty()); + + // Not a valid JSON + QByteArray notValid2("{A normal string}"); + result = browserHost.parseMessage(notValid2, 0); + QVERIFY(result.isEmpty()); + + // Not a valid JSON + QByteArray notValid3("{A normal string"); + result = browserHost.parseMessage(notValid3, 0); + QVERIFY(result.isEmpty()); + + // If multiple, only first one gets parsed. parseMessage() does not handle coalesced messages. + QByteArray multipleMessages( + R"({"action": "test-action", "nonce": "testnonce"}{"action": "test-action2", "nonce": "testnonce2"})"); + result = browserHost.parseMessage(normalMessage, 0); + QVERIFY(result.value("action") == "test-action" && result.value("nonce") == "testnonce"); + + // Garbage at the start + QByteArray garbageAtStart(R"(GARBAGE{"action": "test-action", "nonce": "testnonce"})"); + result = browserHost.parseMessage(garbageAtStart, 0); + QVERIFY(result.value("action") == "test-action" && result.value("nonce") == "testnonce"); + + // Garbage at the start with fragmentation + QByteArray garbageAtStartWithFragmentation(R"(GARBAGE{"action": "test-action", "nonce": "testno)"); + result = browserHost.parseMessage(garbageAtStartWithFragmentation, 0); + QVERIFY(result.isEmpty()); + + // Garbage at the end + QByteArray garbageAtEnd(R"({"action": "test-action", "nonce": "testnonce"}GARBAGE)"); + result = browserHost.parseMessage(garbageAtEnd, 0); + QVERIFY(result.value("action") == "test-action" && result.value("nonce") == "testnonce"); + + // Garbage at the end as NULL chars + QByteArray garbageAtEndNull(R"({"action": "test-action", "nonce": "testnonce"}GARBAGE)"); + garbageAtEndNull.append('\0'); + garbageAtEndNull.append('\0'); + result = browserHost.parseMessage(garbageAtEndNull, 0); + QVERIFY(result.value("action") == "test-action" && result.value("nonce") == "testnonce"); + + // Garbage at the start and end + QByteArray garbageAtBoth(R"(GARBAGE{"action": "test-action", "nonce": "testnonce"}GARBAGE)"); + result = browserHost.parseMessage(garbageAtBoth, 0); + QVERIFY(result.value("action") == "test-action" && result.value("nonce") == "testnonce"); +} + +void TestBrowser::testBrowserHostFragmentedMessaging() +{ + BrowserHost browserHost; + + // Data has been fragmented between two messages. This is the original for comparison. + const auto originalMessage = + QJsonObject{{"action", "get-database-groups"}, + {"message", "+zjtntnk4rGWSl/Ph7Vqip/swvgeupk4lNgHEm2OO3ujNr0OMz6eQtGwjtsj+/rP"}, + {"nonce", "tZvLrBzkQ9GxXq9PvKJj4iAnfPT0VZ3Q"}, + {"clientID", "clientID"}}; + + // Second parse should return the original message + const QByteArray fragmentedFirst = + R"({"action":"get-database-groups","message":"+zjtntnk4rGWSl/Ph7Vqip/swvgeupk4lNgHEm2OO3ujNr0OMz6eQtGwjtsj+/rP","nonce":"tZvLrBzkQ9GxXq)"; + const QByteArray fragmentedSecond = R"(9PvKJj4iAnfPT0VZ3Q","clientID":"clientID"})"; + auto result = browserHost.parseMessage(fragmentedFirst, 0); + result = browserHost.parseMessage(fragmentedSecond, 0); + QVERIFY(result == originalMessage); + + // Different kind of fragmentation, comes from different socket + const QByteArray fragmentedTest = + R"({"action": "get-database-groups","message": "+zjtntnk4rGWSl/Ph7Vqip/swvgeupk4lNgHEm2OO3ujNr0OMz6eQtGwjtsj+/rP",)"; + const QByteArray fragmentedTest2 = R"("nonce": "tZvLrBzkQ9GxXq9PvKJj4iAnfPT0VZ3Q","clientID": "clientID"})"; + result = browserHost.parseMessage(fragmentedTest, 1); + result = browserHost.parseMessage(fragmentedTest2, 1); + QVERIFY(result == originalMessage); + + // Different kind of fragmentation, comes from different socket + const QByteArray fragmentedTest3 = + R"({"action": "get-database-groups","message": "+zjtntnk4rGWSl/Ph7Vqip/swvgeupk4lNgHEm2OO3ujNr0OMz6eQtGwjtsj+/rP")"; + const QByteArray fragmentedTest4 = R"(,"nonce": "tZvLrBzkQ9GxXq9PvKJj4iAnfPT0VZ3Q","clientID": "clientID"})"; + result = browserHost.parseMessage(fragmentedTest3, 2); + result = browserHost.parseMessage(fragmentedTest4, 2); + QVERIFY(result == originalMessage); + + // Maximum message size (set to 70) in the last check) exceeded during fragmented message parsing. + // It is multiplied by MAX_FRAGMENTED_FRAMES (3) + const QByteArray fragmentedTest5 = + R"({"action": "get-database-groups","message": "+zjtntnk4rGWSl/Ph7Vqip/swvgeupk4lNgHEm2OO3ujNr0OMz6eQtGwjtsj+/rP")"; + const QByteArray fragmentedTest6 = R"(,"nonce": "tZvLrBzkQ9GxXq9PvKJj4iAnfPT0VZ3Q","clientID": "clientID"})"; + result = browserHost.parseMessage(fragmentedTest5, 2); + result = browserHost.parseMessage(fragmentedTest6, 2, 70); + QVERIFY(result.isEmpty()); + + // Test two fragmented frames after the first one + const QByteArray threeFragmented1 = R"({"action":"get-database-groups","message":)"; + const QByteArray threeFragmented2 = + R"("+zjtntnk4rGWSl/Ph7Vqip/swvgeupk4lNgHEm2OO3ujNr0OMz6eQtGwjtsj+/rP","nonce":"tZvLrBzkQ9GxXq)"; + const QByteArray threeFragmented3 = R"(9PvKJj4iAnfPT0VZ3Q","clientID":"clientID"})"; + result = browserHost.parseMessage(threeFragmented1, 3); + result = browserHost.parseMessage(threeFragmented2, 3); + result = browserHost.parseMessage(threeFragmented3, 3); + QVERIFY(result == originalMessage); + + // Two sockets are receiving fragmented messages in mixed order from different sockets + const auto secondOriginalMessage = + QJsonObject{{"action", "get-database-hash"}, + {"message", "+zjtntnk4rGWSl/Ph7Vqip/swvgeupk4lNgHEm2OO3ujNr0OMz6eQtGwjtsj+/rP"}, + {"nonce", "tZvLrBzkQ9GxXq9PvKJj4iAnfPT0VZ3Q"}, + {"clientID", "clientID2"}}; + const QByteArray mixedOrderFirst1 = + R"({"action": "get-database-groups","message": "+zjtntnk4rGWSl/Ph7Vqip/swvgeupk4lNgHEm2OO3ujNr0OMz6eQtGwjtsj+/rP")"; + const QByteArray mixedOrderFirst2 = R"(,"nonce": "tZvLrBzkQ9GxXq9PvKJj4iAnfPT0VZ3Q","clientID": "clientID"})"; + const QByteArray mixedOrderSecond1 = + R"({"action": "get-database-hash","message": "+zjtntnk4rGWSl/Ph7Vqip/swvgeupk4lNgHEm2OO3ujNr0OMz6eQtGwjtsj+/rP")"; + const QByteArray mixedOrderSecond2 = R"(,"nonce": "tZvLrBzkQ9GxXq9PvKJj4iAnfPT0VZ3Q","clientID": "clientID2"})"; + auto resultFirst = browserHost.parseMessage(mixedOrderFirst1, 4); + auto resultSecond = browserHost.parseMessage(mixedOrderSecond1, 5); + resultFirst = browserHost.parseMessage(mixedOrderFirst2, 4); + resultSecond = browserHost.parseMessage(mixedOrderSecond2, 5); + QVERIFY(resultFirst == originalMessage); + QVERIFY(resultSecond == secondOriginalMessage); +} + +void TestBrowser::testBrowserHostCoalescedMessaging() +{ + BrowserHost browserHost; + + // These two are sent together, or together and fragmented + const auto firstOriginalMessage = QJsonObject{{"nonce", "tZvLrBzkQ9GxXq9PvKJj4iAnfPT0VZ3Q"}}; + const auto secondOriginalMessage = QJsonObject{{"clientID", "clientID"}}; + + // A basic coalesced message + const QByteArray coalesced = R"({"nonce":"tZvLrBzkQ9GxXq9PvKJj4iAnfPT0VZ3Q"}{"clientID":"clientID"})"; + auto result = browserHost.parseSocketData(coalesced, 0); + QVERIFY(result.length() == 2); + QCOMPARE(result.at(0), firstOriginalMessage); + QCOMPARE(result.at(1), secondOriginalMessage); + + // Coalesced but fragmented in first message + const QByteArray fragmented1 = R"({"nonce":"tZvLrBzkQ9GxXq9PvKJj4i)"; + const QByteArray fragmented2 = R"(AnfPT0VZ3Q"}{"clientID":"clientID"})"; + result = browserHost.parseSocketData(fragmented1, 0); + QVERIFY(result.isEmpty()); // No messages parsed yet + result = browserHost.parseSocketData(fragmented2, 0); + QVERIFY(result.length() == 2); + QCOMPARE(result.at(0), firstOriginalMessage); + QCOMPARE(result.at(1), secondOriginalMessage); + + // Coalesced but fragmented in second message. First one should return the "nonce", and cache the start of "client". + const QByteArray fragmented3 = R"({"nonce":"tZvLrBzkQ9GxXq9PvKJj4iAnfPT0VZ3Q"}{"client)"; + const QByteArray fragmented4 = R"(ID":"clientID"})"; + result = browserHost.parseSocketData(fragmented3, 0); + QCOMPARE(result.first(), firstOriginalMessage); + result = browserHost.parseSocketData(fragmented4, 0); + QCOMPARE(result.first(), secondOriginalMessage); + + // Three fragmented messages with coalesced data + const QByteArray fragmented5 = R"({"nonce":"tZvLrBzkQ9GxXq9PvKJj4iAnfPT0VZ3Q"}{"cli)"; + const QByteArray fragmented6 = R"(entID":"clie)"; + const QByteArray fragmented7 = R"(ntID"})"; + result = browserHost.parseSocketData(fragmented5, 0); + QVERIFY(result.length() == 1); + QCOMPARE(result.first(), firstOriginalMessage); + result = browserHost.parseSocketData(fragmented6, 0); + QVERIFY(result.isEmpty()); // Still caching + result = browserHost.parseSocketData(fragmented7, 0); + QVERIFY(result.length() == 1); + QCOMPARE(result.first(), secondOriginalMessage); +} diff --git a/tests/TestBrowser.h b/tests/TestBrowser.h index 171389e51..9b1b80cc8 100644 --- a/tests/TestBrowser.h +++ b/tests/TestBrowser.h @@ -52,6 +52,9 @@ private slots: void testBestMatchingWithAdditionalURLs(); void testRestrictBrowserKey(); void testHideEntry(); + void testBrowserHostMessaging(); + void testBrowserHostFragmentedMessaging(); + void testBrowserHostCoalescedMessaging(); private: QList createEntries(QStringList& urls, Group* root, bool additionalUrl = false) const;