1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
|
// SPDX-FileCopyrightText: 2021 Carl Schwan <carlschwan@kde.org>
//
// SPDX-License-Identifier: LGPL-2.1-or-later
#ifdef Quotient_E2EE_ENABLED
#include "qolmaccount.h"
#include "olm/utils.h"
#include <QJsonObject>
#include <QJsonDocument>
#include <QDebug>
#include <iostream>
using namespace Quotient;
QMap<QString, QString> OneTimeKeys::curve25519() const
{
return keys[QStringLiteral("curve25519")];
}
std::optional<QMap<QString, QString>> OneTimeKeys::get(QString keyType) const
{
if (!keys.contains(keyType)) {
return std::nullopt;
}
return keys[keyType];
}
bool operator==(const IdentityKeys& lhs, const IdentityKeys& rhs)
{
return lhs.curve25519 == rhs.curve25519 &&& lhs.ed25519 == rhs.ed25519;
}
// Conver olm error to enum
OlmError lastError(OlmAccount *account) {
const std::string error_raw = olm_account_last_error(account);
return fromString(error_raw);
}
QByteArray getRandom(size_t bufferSize)
{
QByteArray buffer(bufferSize, '0');
std::generate(buffer.begin(), buffer.end(), std::rand);
return buffer;
}
QOlmAccount::QOlmAccount(OlmAccount *account)
: m_account(account)
{}
QOlmAccount::~QOlmAccount()
{
olm_clear_account(m_account);
}
std::optional<QOlmAccount> QOlmAccount::create()
{
auto account = olm_account(new uint8_t[olm_account_size()]);
size_t randomSize = olm_create_account_random_length(account);
QByteArray randomData = getRandom(randomSize);
const auto error = olm_create_account(account, randomData.data(), randomSize);
if (error == olm_error()) {
return std::nullopt;
}
return std::make_optional<QOlmAccount>(account);
}
std::variant<QOlmAccount, OlmError> QOlmAccount::unpickle(QByteArray &pickled, const PicklingMode &mode)
{
auto account = olm_account(new uint8_t[olm_account_size()]);
const QByteArray key = toKey(mode);
const auto error = olm_unpickle_account(account, key.data(), key.length(), pickled.data(), pickled.size());
if (error == olm_error()) {
return lastError(account);
}
return QOlmAccount(account);
}
std::variant<QByteArray, OlmError> QOlmAccount::pickle(const PicklingMode &mode)
{
const QByteArray key = toKey(mode);
const size_t pickleLength = olm_pickle_account_length(m_account);
QByteArray pickleBuffer(pickleLength, '0');
const auto error = olm_pickle_account(m_account, key.data(),
key.length(), pickleBuffer.data(), pickleLength);
if (error == olm_error()) {
return lastError(m_account);
}
return pickleBuffer;
}
std::variant<IdentityKeys, OlmError> QOlmAccount::identityKeys()
{
const size_t keyLength = olm_account_identity_keys_length(m_account);
QByteArray keyBuffer(keyLength, '0');
const auto error = olm_account_identity_keys(m_account, keyBuffer.data(), keyLength);
if (error == olm_error()) {
return lastError(m_account);
}
const QJsonObject key = QJsonDocument::fromJson(keyBuffer).object();
return IdentityKeys {
key.value(QStringLiteral("curve25519")).toString().toUtf8(),
key.value(QStringLiteral("ed25519")).toString().toUtf8()
};
}
std::variant<QString, OlmError> QOlmAccount::sign(const QString &message) const
{
const size_t signatureLength = olm_account_signature_length(m_account);
QByteArray signatureBuffer(signatureLength, '0');
const auto error = olm_account_sign(m_account, message.data(), message.length(),
signatureBuffer.data(), signatureLength);
if (error == olm_error()) {
return lastError(m_account);
}
return QString::fromUtf8(signatureBuffer);
}
size_t QOlmAccount::maxNumberOfOneTimeKeys() const
{
return olm_account_max_number_of_one_time_keys(m_account);
}
std::optional<OlmError> QOlmAccount::generateOneTimeKeys(size_t numberOfKeys) const
{
const size_t randomLen = olm_account_generate_one_time_keys_random_length(m_account, numberOfKeys);
QByteArray randomBuffer = getRandom(randomLen);
const auto error = olm_account_generate_one_time_keys(m_account, numberOfKeys, randomBuffer.data(), randomLen);
if (error == olm_error()) {
return lastError(m_account);
}
return std::nullopt;
}
std::variant<OneTimeKeys, OlmError> QOlmAccount::oneTimeKeys() const
{
const size_t oneTimeKeyLength = olm_account_one_time_keys_length(m_account);
QByteArray oneTimeKeysBuffer(oneTimeKeyLength, '0');
const auto error = olm_account_one_time_keys(m_account, oneTimeKeysBuffer.data(), oneTimeKeyLength);
if (error == olm_error()) {
return lastError(m_account);
}
const auto json = QJsonDocument::fromJson(oneTimeKeysBuffer).object();
OneTimeKeys oneTimeKeys;
for (const QJsonValue &key1 : json.keys()) {
auto oneTimeKeyObject = json[key1.toString()].toObject();
auto keyMap = QMap<QString, QString>();
for (const QString &key2 : oneTimeKeyObject.keys()) {
keyMap[key2] = oneTimeKeyObject[key2].toString();
}
oneTimeKeys.keys[key1.toString()] = keyMap;
}
return oneTimeKeys;
}
#endif
|
