Branch data Line data Source code
1 : : // Copyright (c) 2020-2022 The Bitcoin Core developers
2 : : // Distributed under the MIT software license, see the accompanying
3 : : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
4 : :
5 : : #include <chainparams.h>
6 : : #include <common/args.h>
7 : : #include <compat/compat.h>
8 : : #include <compat/endian.h>
9 : : #include <crypto/sha256.h>
10 : : #include <i2p.h>
11 : : #include <logging.h>
12 : : #include <netaddress.h>
13 : : #include <netbase.h>
14 : : #include <random.h>
15 : : #include <tinyformat.h>
16 : : #include <util/fs.h>
17 : : #include <util/readwritefile.h>
18 : : #include <util/sock.h>
19 : : #include <util/spanparsing.h>
20 : : #include <util/strencodings.h>
21 : : #include <util/threadinterrupt.h>
22 : :
23 : : #include <chrono>
24 : : #include <memory>
25 : : #include <stdexcept>
26 : : #include <string>
27 : :
28 : : namespace i2p {
29 : :
30 : : /**
31 : : * Swap Standard Base64 <-> I2P Base64.
32 : : * Standard Base64 uses `+` and `/` as last two characters of its alphabet.
33 : : * I2P Base64 uses `-` and `~` respectively.
34 : : * So it is easy to detect in which one is the input and convert to the other.
35 : : * @param[in] from Input to convert.
36 : : * @return converted `from`
37 : : */
38 : 0 : static std::string SwapBase64(const std::string& from)
39 : : {
40 : 0 : std::string to;
41 [ # # ]: 0 : to.resize(from.size());
42 [ # # ]: 0 : for (size_t i = 0; i < from.size(); ++i) {
43 [ # # # # : 0 : switch (from[i]) {
# ]
44 : : case '-':
45 [ # # ]: 0 : to[i] = '+';
46 : 0 : break;
47 : : case '~':
48 [ # # ]: 0 : to[i] = '/';
49 : 0 : break;
50 : : case '+':
51 [ # # ]: 0 : to[i] = '-';
52 : 0 : break;
53 : : case '/':
54 [ # # ]: 0 : to[i] = '~';
55 : 0 : break;
56 : : default:
57 [ # # ]: 0 : to[i] = from[i];
58 : 0 : break;
59 : : }
60 : 0 : }
61 : 0 : return to;
62 [ # # ]: 0 : }
63 : :
64 : : /**
65 : : * Decode an I2P-style Base64 string.
66 : : * @param[in] i2p_b64 I2P-style Base64 string.
67 : : * @return decoded `i2p_b64`
68 : : * @throw std::runtime_error if decoding fails
69 : : */
70 : 0 : static Binary DecodeI2PBase64(const std::string& i2p_b64)
71 : : {
72 : 0 : const std::string& std_b64 = SwapBase64(i2p_b64);
73 [ # # ]: 0 : auto decoded = DecodeBase64(std_b64);
74 [ # # ]: 173 : if (!decoded) {
75 [ # # # # : 0 : throw std::runtime_error(strprintf("Cannot decode Base64: \"%s\"", i2p_b64));
# # # # ]
76 : : }
77 [ # # ]: 0 : return std::move(*decoded);
78 : 0 : }
79 : :
80 : : /**
81 : : * Derive the .b32.i2p address of an I2P destination (binary).
82 : : * @param[in] dest I2P destination.
83 : : * @return the address that corresponds to `dest`
84 : : * @throw std::runtime_error if conversion fails
85 : : */
86 : 0 : static CNetAddr DestBinToAddr(const Binary& dest)
87 : : {
88 : 0 : CSHA256 hasher;
89 : 0 : hasher.Write(dest.data(), dest.size());
90 : : unsigned char hash[CSHA256::OUTPUT_SIZE];
91 : 0 : hasher.Finalize(hash);
92 : :
93 : 0 : CNetAddr addr;
94 [ # # # # ]: 0 : const std::string addr_str = EncodeBase32(hash, false) + ".b32.i2p";
95 [ # # # # ]: 0 : if (!addr.SetSpecial(addr_str)) {
96 [ # # # # : 0 : throw std::runtime_error(strprintf("Cannot parse I2P address: \"%s\"", addr_str));
# # # # ]
97 : : }
98 : :
99 : 0 : return addr;
100 [ # # ]: 0 : }
101 : :
102 : : /**
103 : : * Derive the .b32.i2p address of an I2P destination (I2P-style Base64).
104 : : * @param[in] dest I2P destination.
105 : : * @return the address that corresponds to `dest`
106 : : * @throw std::runtime_error if conversion fails
107 : : */
108 : 0 : static CNetAddr DestB64ToAddr(const std::string& dest)
109 : : {
110 : 0 : const Binary& decoded = DecodeI2PBase64(dest);
111 [ # # ]: 0 : return DestBinToAddr(decoded);
112 : 0 : }
113 : :
114 : : namespace sam {
115 : :
116 [ - + ]: 92 : Session::Session(const fs::path& private_key_file,
117 : : const CService& control_host,
118 : : CThreadInterrupt* interrupt)
119 : 92 : : m_private_key_file{private_key_file},
120 [ + - ]: 92 : m_control_host{control_host},
121 : 92 : m_interrupt{interrupt},
122 : 92 : m_transient{false}
123 : : {
124 : 92 : }
125 : :
126 [ # # ]: 0 : Session::Session(const CService& control_host, CThreadInterrupt* interrupt)
127 [ # # ]: 0 : : m_control_host{control_host},
128 : 0 : m_interrupt{interrupt},
129 : 0 : m_transient{true}
130 : : {
131 : 0 : }
132 : :
133 : 92 : Session::~Session()
134 : : {
135 [ + - + - ]: 92 : LOCK(m_mutex);
136 [ + - ]: 92 : Disconnect();
137 : 92 : }
138 : :
139 : 92 : bool Session::Listen(Connection& conn)
140 : : {
141 : : try {
142 [ + - + - ]: 92 : LOCK(m_mutex);
143 [ - + ]: 92 : CreateIfNotCreatedAlready();
144 [ # # ]: 0 : conn.me = m_my_addr;
145 [ # # ]: 0 : conn.sock = StreamAccept();
146 : 0 : return true;
147 [ - + ]: 92 : } catch (const std::runtime_error& e) {
148 [ + - + - ]: 92 : Log("Error listening: %s", e.what());
149 [ + - ]: 92 : CheckControlSock();
150 [ # # ]: 92 : }
151 : 92 : return false;
152 : 184 : }
153 : :
154 : 0 : bool Session::Accept(Connection& conn)
155 : : {
156 : : try {
157 [ # # # # ]: 0 : while (!*m_interrupt) {
158 : : Sock::Event occurred;
159 [ # # # # : 0 : if (!conn.sock->Wait(MAX_WAIT_FOR_IO, Sock::RECV, &occurred)) {
# # ]
160 [ # # # # ]: 0 : throw std::runtime_error("wait on socket failed");
161 : : }
162 : :
163 [ # # ]: 0 : if (occurred == 0) {
164 : : // Timeout, no incoming connections or errors within MAX_WAIT_FOR_IO.
165 : 0 : continue;
166 : : }
167 : :
168 : 0 : const std::string& peer_dest =
169 [ # # # # ]: 0 : conn.sock->RecvUntilTerminator('\n', MAX_WAIT_FOR_IO, *m_interrupt, MAX_MSG_SIZE);
170 : :
171 [ # # # # ]: 0 : conn.peer = CService(DestB64ToAddr(peer_dest), I2P_SAM31_PORT);
172 : :
173 : 0 : return true;
174 : 0 : }
175 [ # # ]: 0 : } catch (const std::runtime_error& e) {
176 [ # # # # ]: 0 : Log("Error accepting: %s", e.what());
177 [ # # ]: 0 : CheckControlSock();
178 [ # # ]: 0 : }
179 : 0 : return false;
180 : 0 : }
181 : :
182 : 92 : bool Session::Connect(const CService& to, Connection& conn, bool& proxy_error)
183 : : {
184 : : // Refuse connecting to arbitrary ports. We don't specify any destination port to the SAM proxy
185 : : // when connecting (SAM 3.1 does not use ports) and it forces/defaults it to I2P_SAM31_PORT.
186 [ - + ]: 92 : if (to.GetPort() != I2P_SAM31_PORT) {
187 : 0 : proxy_error = false;
188 : 0 : return false;
189 : : }
190 : :
191 : 92 : proxy_error = true;
192 : :
193 : 92 : std::string session_id;
194 : 92 : std::unique_ptr<Sock> sock;
195 [ + - ]: 92 : conn.peer = to;
196 : :
197 : : try {
198 : : {
199 [ + - + - ]: 92 : LOCK(m_mutex);
200 [ - + ]: 92 : CreateIfNotCreatedAlready();
201 [ # # ]: 0 : session_id = m_session_id;
202 [ # # ]: 0 : conn.me = m_my_addr;
203 [ # # ]: 0 : sock = Hello();
204 : 92 : }
205 : :
206 : 0 : const Reply& lookup_reply =
207 [ # # # # : 0 : SendRequestAndGetReply(*sock, strprintf("NAMING LOOKUP NAME=%s", to.ToStringAddr()));
# # # # ]
208 : :
209 [ # # # # ]: 0 : const std::string& dest = lookup_reply.Get("VALUE");
210 : :
211 [ # # ]: 0 : const Reply& connect_reply = SendRequestAndGetReply(
212 [ # # # # ]: 0 : *sock, strprintf("STREAM CONNECT ID=%s DESTINATION=%s SILENT=false", session_id, dest),
213 : : false);
214 : :
215 [ # # # # ]: 0 : const std::string& result = connect_reply.Get("RESULT");
216 : :
217 [ # # # # ]: 0 : if (result == "OK") {
218 : 0 : conn.sock = std::move(sock);
219 : 0 : return true;
220 : : }
221 : :
222 [ # # # # ]: 0 : if (result == "INVALID_ID") {
223 [ # # # # ]: 0 : LOCK(m_mutex);
224 [ # # ]: 0 : Disconnect();
225 [ # # ]: 0 : throw std::runtime_error("Invalid session id");
226 : 0 : }
227 : :
228 [ # # # # : 0 : if (result == "CANT_REACH_PEER" || result == "TIMEOUT") {
# # # # ]
229 : 0 : proxy_error = false;
230 : 0 : }
231 : :
232 [ # # # # : 0 : throw std::runtime_error(strprintf("\"%s\"", connect_reply.full));
# # ]
233 [ - + ]: 92 : } catch (const std::runtime_error& e) {
234 [ + - + - : 92 : Log("Error connecting to %s: %s", to.ToStringAddrPort(), e.what());
+ - ]
235 [ + - ]: 92 : CheckControlSock();
236 : 92 : return false;
237 [ + - # # ]: 92 : }
238 : 184 : }
239 : :
240 : : // Private methods
241 : :
242 : 78 : std::string Session::Reply::Get(const std::string& key) const
243 : : {
244 : 78 : const auto& pos = keys.find(key);
245 [ + + + + ]: 78 : if (pos == keys.end() || !pos->second.has_value()) {
246 [ + - - + : 59 : throw std::runtime_error(
+ - ]
247 [ + - ]: 59 : strprintf("Missing %s= in the reply to \"%s\": \"%s\"", key, request, full));
248 : : }
249 : 19 : return pos->second.value();
250 : 59 : }
251 : :
252 : : template <typename... Args>
253 : 368 : void Session::Log(const std::string& fmt, const Args&... args) const
254 : : {
255 [ + - # # : 368 : LogPrint(BCLog::I2P, "%s\n", tfm::format(fmt, args...));
# # # # #
# + - # #
# # # # #
# # # # #
# # # # #
# + - # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# ]
256 : 368 : }
257 : :
258 : 171 : Session::Reply Session::SendRequestAndGetReply(const Sock& sock,
259 : : const std::string& request,
260 : : bool check_result_ok) const
261 : : {
262 [ + - + + ]: 266 : sock.SendComplete(request + "\n", MAX_WAIT_FOR_IO, *m_interrupt);
263 : :
264 : 116 : Reply reply;
265 : :
266 : : // Don't log the full "SESSION CREATE ..." because it contains our private key.
267 [ + - + - : 116 : reply.request = request.substr(0, 14) == "SESSION CREATE" ? "SESSION CREATE ..." : request;
+ - # # +
- + - + -
# # ]
268 : :
269 : : // It could take a few minutes for the I2P router to reply as it is querying the I2P network
270 : : // (when doing name lookup, for example). Notice: `RecvUntilTerminator()` is checking
271 : : // `m_interrupt` more often, so we would not be stuck here for long if `m_interrupt` is
272 : : // signaled.
273 : : static constexpr auto recv_timeout = 3min;
274 : :
275 [ + - + + ]: 116 : reply.full = sock.RecvUntilTerminator('\n', recv_timeout, *m_interrupt, MAX_MSG_SIZE);
276 : :
277 [ + - + - : 50162 : for (const auto& kv : spanparsing::Split(reply.full, ' ')) {
+ + ]
278 [ + - ]: 50084 : const auto& pos = std::find(kv.begin(), kv.end(), '=');
279 [ + + ]: 50084 : if (pos != kv.end()) {
280 [ + - - + : 355 : reply.keys.emplace(std::string{kv.begin(), pos}, std::string{pos + 1, kv.end()});
+ - ]
281 : 355 : } else {
282 [ + - - + ]: 49729 : reply.keys.emplace(std::string{kv.begin(), kv.end()}, std::nullopt);
283 : : }
284 : : }
285 : :
286 [ + + + - : 147 : if (check_result_ok && reply.Get("RESULT") != "OK") {
+ + + - +
+ + + + +
+ + # # -
+ - + ]
287 [ + - - + : 7 : throw std::runtime_error(
+ - ]
288 [ + - ]: 7 : strprintf("Unexpected reply to \"%s\": \"%s\"", request, reply.full));
289 : : }
290 : :
291 : 21 : return reply;
292 [ + - ]: 228 : }
293 : :
294 : 184 : std::unique_ptr<Sock> Session::Hello() const
295 : : {
296 : 184 : auto sock = CreateSock(m_control_host);
297 : :
298 [ + - ]: 184 : if (!sock) {
299 [ # # ]: 0 : throw std::runtime_error("Cannot create socket");
300 : : }
301 : :
302 [ + - + - : 184 : if (!ConnectSocketDirectly(m_control_host, *sock, nConnectTimeout, true)) {
+ + ]
303 [ + - + - : 25 : throw std::runtime_error(strprintf("Cannot connect to %s", m_control_host.ToStringAddrPort()));
+ - + - ]
304 : : }
305 : :
306 [ + - + - : 159 : SendRequestAndGetReply(*sock, "HELLO VERSION MIN=3.1 MAX=3.1");
+ + ]
307 : :
308 : 12 : return sock;
309 [ + - ]: 356 : }
310 : :
311 : 184 : void Session::CheckControlSock()
312 : : {
313 : 184 : LOCK(m_mutex);
314 : :
315 : 184 : std::string errmsg;
316 [ + - # # : 184 : if (m_control_sock && !m_control_sock->IsConnected(errmsg)) {
# # ]
317 [ # # # # ]: 0 : Log("Control socket error: %s", errmsg);
318 [ # # ]: 0 : Disconnect();
319 : 0 : }
320 : 184 : }
321 : :
322 : 12 : void Session::DestGenerate(const Sock& sock)
323 : : {
324 : : // https://geti2p.net/spec/common-structures#key-certificates
325 : : // "7" or "EdDSA_SHA512_Ed25519" - "Recent Router Identities and Destinations".
326 : : // Use "7" because i2pd <2.24.0 does not recognize the textual form.
327 : : // If SIGNATURE_TYPE is not specified, then the default one is DSA_SHA1.
328 [ + - + + ]: 21 : const Reply& reply = SendRequestAndGetReply(sock, "DEST GENERATE SIGNATURE_TYPE=7", false);
329 : :
330 [ + - - + : 18 : m_private_key = DecodeI2PBase64(reply.Get("PRIV"));
# # ]
331 : 21 : }
332 : :
333 : 0 : void Session::GenerateAndSavePrivateKey(const Sock& sock)
334 : : {
335 : 0 : DestGenerate(sock);
336 : :
337 : : // umask is set to 0077 in common/system.cpp, which is ok.
338 [ # # # # ]: 0 : if (!WriteBinaryFile(m_private_key_file,
339 [ # # ]: 0 : std::string(m_private_key.begin(), m_private_key.end()))) {
340 [ # # # # : 0 : throw std::runtime_error(
# # ]
341 [ # # # # : 0 : strprintf("Cannot save I2P private key to %s", fs::quoted(fs::PathToString(m_private_key_file))));
# # ]
342 : : }
343 : 0 : }
344 : :
345 : 0 : Binary Session::MyDestination() const
346 : : {
347 : : // From https://geti2p.net/spec/common-structures#destination:
348 : : // "They are 387 bytes plus the certificate length specified at bytes 385-386, which may be
349 : : // non-zero"
350 : : static constexpr size_t DEST_LEN_BASE = 387;
351 : : static constexpr size_t CERT_LEN_POS = 385;
352 : :
353 : : uint16_t cert_len;
354 : 0 : memcpy(&cert_len, &m_private_key.at(CERT_LEN_POS), sizeof(cert_len));
355 : 0 : cert_len = be16toh(cert_len);
356 : :
357 : 0 : const size_t dest_len = DEST_LEN_BASE + cert_len;
358 : :
359 [ # # ]: 0 : return Binary{m_private_key.begin(), m_private_key.begin() + dest_len};
360 : 0 : }
361 : :
362 : 184 : void Session::CreateIfNotCreatedAlready()
363 : : {
364 : 184 : std::string errmsg;
365 [ - + # # : 184 : if (m_control_sock && m_control_sock->IsConnected(errmsg)) {
# # ]
366 : 0 : return;
367 : : }
368 : :
369 : 184 : const auto session_type = m_transient ? "transient" : "persistent";
370 [ + - + - ]: 184 : const auto session_id = GetRandHash().GetHex().substr(0, 10); // full is overkill, too verbose in the logs
371 : :
372 [ + - + - : 184 : Log("Creating %s SAM session %s with %s", session_type, session_id, m_control_host.ToStringAddrPort());
+ - ]
373 : :
374 [ + + ]: 184 : auto sock = Hello();
375 : :
376 [ - + ]: 12 : if (m_transient) {
377 : : // The destination (private key) is generated upon session creation and returned
378 : : // in the reply in DESTINATION=.
379 [ # # ]: 0 : const Reply& reply = SendRequestAndGetReply(
380 [ # # ]: 0 : *sock,
381 [ # # ]: 0 : strprintf("SESSION CREATE STYLE=STREAM ID=%s DESTINATION=TRANSIENT SIGNATURE_TYPE=7 "
382 : : "inbound.quantity=1 outbound.quantity=1",
383 : : session_id));
384 : :
385 [ # # # # : 0 : m_private_key = DecodeI2PBase64(reply.Get("DESTINATION"));
# # ]
386 : 0 : } else {
387 : : // Read our persistent destination (private key) from disk or generate
388 : : // one and save it to disk. Then use it when creating the session.
389 [ + - ]: 12 : const auto& [read_ok, data] = ReadBinaryFile(m_private_key_file);
390 [ - + ]: 12 : if (read_ok) {
391 [ # # # # : 0 : m_private_key.assign(data.begin(), data.end());
# # ]
392 : 0 : } else {
393 [ + - - + ]: 12 : GenerateAndSavePrivateKey(*sock);
394 : : }
395 : :
396 [ # # # # : 0 : const std::string& private_key_b64 = SwapBase64(EncodeBase64(m_private_key));
# # ]
397 : :
398 [ # # # # ]: 0 : SendRequestAndGetReply(*sock,
399 [ # # ]: 0 : strprintf("SESSION CREATE STYLE=STREAM ID=%s DESTINATION=%s "
400 : : "inbound.quantity=3 outbound.quantity=3",
401 : : session_id,
402 : 0 : private_key_b64));
403 : 12 : }
404 : :
405 [ # # # # : 0 : m_my_addr = CService(DestBinToAddr(MyDestination()), I2P_SAM31_PORT);
# # ]
406 [ # # ]: 0 : m_session_id = session_id;
407 : 0 : m_control_sock = std::move(sock);
408 : :
409 [ # # # # ]: 0 : Log("%s SAM session %s created, my address=%s",
410 [ # # # # ]: 0 : Capitalize(session_type),
411 : 0 : m_session_id,
412 [ # # ]: 0 : m_my_addr.ToStringAddrPort());
413 [ # # ]: 196 : }
414 : :
415 : 0 : std::unique_ptr<Sock> Session::StreamAccept()
416 : : {
417 : 0 : auto sock = Hello();
418 : :
419 [ # # ]: 0 : const Reply& reply = SendRequestAndGetReply(
420 [ # # # # ]: 0 : *sock, strprintf("STREAM ACCEPT ID=%s SILENT=false", m_session_id), false);
421 : :
422 [ # # # # ]: 0 : const std::string& result = reply.Get("RESULT");
423 : :
424 [ # # # # ]: 0 : if (result == "OK") {
425 : 0 : return sock;
426 : : }
427 : :
428 [ # # # # ]: 0 : if (result == "INVALID_ID") {
429 : : // If our session id is invalid, then force session re-creation on next usage.
430 [ # # ]: 0 : Disconnect();
431 : 0 : }
432 : :
433 [ # # # # : 0 : throw std::runtime_error(strprintf("\"%s\"", reply.full));
# # # # ]
434 [ # # ]: 0 : }
435 : :
436 : 92 : void Session::Disconnect()
437 : : {
438 [ + - ]: 92 : if (m_control_sock) {
439 [ # # ]: 0 : if (m_session_id.empty()) {
440 [ # # # # ]: 0 : Log("Destroying incomplete SAM session");
441 : 0 : } else {
442 [ # # # # ]: 0 : Log("Destroying SAM session %s", m_session_id);
443 : : }
444 : 0 : m_control_sock.reset();
445 : 0 : }
446 : 92 : m_session_id.clear();
447 : 92 : }
448 : : } // namespace sam
449 : : } // namespace i2p
|
