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
|
// SPDX-FileCopyrightText: 2019 Alexey Andreyev <aa13q@ya.ru>
// SPDX-FileCopyrightText: 2019 Kitsune Ral <Kitsune-Ral@users.sf.net>
// SPDX-FileCopyrightText: 2021 Carl Schwan <carlschwan@kde.org>
// SPDX-License-Identifier: LGPL-2.1-or-later
#pragma once
#include "converters.h"
#include "expected.h"
#include "qolmerrors.h"
#include <QtCore/QMetaType>
#include <QtCore/QStringBuilder>
#include <array>
#include <variant>
namespace Quotient {
constexpr auto CiphertextKeyL = "ciphertext"_ls;
constexpr auto SenderKeyKeyL = "sender_key"_ls;
constexpr auto DeviceIdKeyL = "device_id"_ls;
constexpr auto SessionIdKeyL = "session_id"_ls;
constexpr auto AlgorithmKeyL = "algorithm"_ls;
constexpr auto RotationPeriodMsKeyL = "rotation_period_ms"_ls;
constexpr auto RotationPeriodMsgsKeyL = "rotation_period_msgs"_ls;
constexpr auto AlgorithmKey = "algorithm"_ls;
constexpr auto RotationPeriodMsKey = "rotation_period_ms"_ls;
constexpr auto RotationPeriodMsgsKey = "rotation_period_msgs"_ls;
constexpr auto Ed25519Key = "ed25519"_ls;
constexpr auto Curve25519Key = "curve25519"_ls;
constexpr auto SignedCurve25519Key = "signed_curve25519"_ls;
constexpr auto OlmV1Curve25519AesSha2AlgoKey = "m.olm.v1.curve25519-aes-sha2"_ls;
constexpr auto MegolmV1AesSha2AlgoKey = "m.megolm.v1.aes-sha2"_ls;
constexpr std::array SupportedAlgorithms { OlmV1Curve25519AesSha2AlgoKey,
MegolmV1AesSha2AlgoKey };
inline bool isSupportedAlgorithm(const QString& algorithm)
{
return std::find(SupportedAlgorithms.cbegin(), SupportedAlgorithms.cend(),
algorithm)
!= SupportedAlgorithms.cend();
}
struct Unencrypted {};
struct Encrypted {
QByteArray key;
};
using PicklingMode = std::variant<Unencrypted, Encrypted>;
class QOlmSession;
using QOlmSessionPtr = std::unique_ptr<QOlmSession>;
class QOlmInboundGroupSession;
using QOlmInboundGroupSessionPtr = std::unique_ptr<QOlmInboundGroupSession>;
class QOlmOutboundGroupSession;
using QOlmOutboundGroupSessionPtr = std::unique_ptr<QOlmOutboundGroupSession>;
template <typename T>
using QOlmExpected = Expected<T, QOlmError>;
struct IdentityKeys
{
QByteArray curve25519;
QByteArray ed25519;
};
//! Struct representing the one-time keys.
struct UnsignedOneTimeKeys
{
QHash<QString, QHash<QString, QString>> keys;
//! Get the HashMap containing the curve25519 one-time keys.
QHash<QString, QString> curve25519() const { return keys[Curve25519Key]; }
};
class SignedOneTimeKey {
public:
explicit SignedOneTimeKey(const QString& unsignedKey, const QString& userId,
const QString& deviceId,
const QByteArray& signature)
: payload { { "key"_ls, unsignedKey },
{ "signatures"_ls,
QJsonObject {
{ userId, QJsonObject { { "ed25519:"_ls % deviceId,
QString(signature) } } } } } }
{}
explicit SignedOneTimeKey(const QJsonObject& jo = {})
: payload(jo)
{}
//! Unpadded Base64-encoded 32-byte Curve25519 public key
QString key() const { return payload["key"_ls].toString(); }
//! \brief Signatures of the key object
//!
//! The signature is calculated using the process described at
//! https://spec.matrix.org/v1.3/appendices/#signing-json
auto signatures() const
{
return fromJson<QHash<QString, QHash<QString, QString>>>(
payload["signatures"_ls]);
}
QByteArray signature(QStringView userId, QStringView deviceId) const
{
return payload["signatures"_ls][userId]["ed25519:"_ls % deviceId]
.toString()
.toLatin1();
}
//! Whether the key is a fallback key
bool isFallback() const { return payload["fallback"_ls].toBool(); }
auto toJson() const { return payload; }
auto toJsonForVerification() const
{
auto json = payload;
json.remove("signatures"_ls);
json.remove("unsigned"_ls);
return QJsonDocument(json).toJson(QJsonDocument::Compact);
}
private:
QJsonObject payload;
};
using OneTimeKeys = QHash<QString, std::variant<QString, SignedOneTimeKey>>;
template <typename T>
class asKeyValueRange
{
public:
asKeyValueRange(T& data)
: m_data { data }
{}
auto begin() { return m_data.keyValueBegin(); }
auto end() { return m_data.keyValueEnd(); }
private:
T &m_data;
};
template <typename T>
asKeyValueRange(T&) -> asKeyValueRange<T>;
} // namespace Quotient
Q_DECLARE_METATYPE(Quotient::SignedOneTimeKey)
|
