Bitcoin ABC  0.26.3
P2P Digital Currency
i2p.cpp
Go to the documentation of this file.
1 // Copyright (c) 2020-2020 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 <i2p.h>
6 
7 #include <chainparams.h>
8 #include <compat.h>
9 #include <compat/endian.h>
10 #include <crypto/sha256.h>
11 #include <fs.h>
12 #include <logging.h>
13 #include <netaddress.h>
14 #include <netbase.h>
15 #include <random.h>
16 #include <tinyformat.h>
17 #include <util/readwritefile.h>
18 #include <util/sock.h>
19 #include <util/spanparsing.h>
20 #include <util/strencodings.h>
21 #include <util/system.h>
22 
23 #include <chrono>
24 #include <memory>
25 #include <stdexcept>
26 #include <string>
27 
28 namespace i2p {
29 
38 static std::string SwapBase64(const std::string &from) {
39  std::string to;
40  to.resize(from.size());
41  for (size_t i = 0; i < from.size(); ++i) {
42  switch (from[i]) {
43  case '-':
44  to[i] = '+';
45  break;
46  case '~':
47  to[i] = '/';
48  break;
49  case '+':
50  to[i] = '-';
51  break;
52  case '/':
53  to[i] = '~';
54  break;
55  default:
56  to[i] = from[i];
57  break;
58  }
59  }
60  return to;
61 }
62 
69 static Binary DecodeI2PBase64(const std::string &i2p_b64) {
70  const std::string &std_b64 = SwapBase64(i2p_b64);
71  bool invalid;
72  Binary decoded = DecodeBase64(std_b64.c_str(), &invalid);
73  if (invalid) {
74  throw std::runtime_error(
75  strprintf("Cannot decode Base64: \"%s\"", i2p_b64));
76  }
77  return decoded;
78 }
79 
86 static CNetAddr DestBinToAddr(const Binary &dest) {
87  CSHA256 hasher;
88  hasher.Write(dest.data(), dest.size());
89  uint8_t hash[CSHA256::OUTPUT_SIZE];
90  hasher.Finalize(hash);
91 
92  CNetAddr addr;
93  const std::string addr_str = EncodeBase32(hash, false) + ".b32.i2p";
94  if (!addr.SetSpecial(addr_str)) {
95  throw std::runtime_error(
96  strprintf("Cannot parse I2P address: \"%s\"", addr_str));
97  }
98 
99  return addr;
100 }
101 
108 static CNetAddr DestB64ToAddr(const std::string &dest) {
109  const Binary &decoded = DecodeI2PBase64(dest);
110  return DestBinToAddr(decoded);
111 }
112 
113 namespace sam {
114 
115  Session::Session(const fs::path &private_key_file,
116  const CService &control_host, CThreadInterrupt *interrupt)
117  : m_private_key_file(private_key_file), m_control_host(control_host),
118  m_interrupt(interrupt),
119  m_control_sock(std::make_unique<Sock>(INVALID_SOCKET)) {}
120 
122  LOCK(m_mutex);
123  Disconnect();
124  }
125 
127  try {
128  LOCK(m_mutex);
130  conn.me = m_my_addr;
131  conn.sock = StreamAccept();
132  return true;
133  } catch (const std::runtime_error &e) {
134  Log("Error listening: %s", e.what());
136  }
137  return false;
138  }
139 
141  try {
142  while (!*m_interrupt) {
143  Sock::Event occurred;
144  conn.sock->Wait(MAX_WAIT_FOR_IO, Sock::RECV, &occurred);
145 
146  if ((occurred & Sock::RECV) == 0) {
147  // Timeout, no incoming connections within MAX_WAIT_FOR_IO.
148  continue;
149  }
150 
151  const std::string &peer_dest = conn.sock->RecvUntilTerminator(
153 
154  conn.peer = CService(DestB64ToAddr(peer_dest), I2P_SAM31_PORT);
155 
156  return true;
157  }
158  } catch (const std::runtime_error &e) {
159  Log("Error accepting: %s", e.what());
161  }
162  return false;
163  }
164 
165  bool Session::Connect(const CService &to, Connection &conn,
166  bool &proxy_error) {
167  // Refuse connecting to arbitrary ports. We don't specify any
168  // destination port to the SAM proxy when connecting (SAM 3.1 does not
169  // use ports) and it forces/defaults it to I2P_SAM31_PORT.
170  if (to.GetPort() != I2P_SAM31_PORT) {
171  proxy_error = false;
172  return false;
173  }
174 
175  proxy_error = true;
176 
177  std::string session_id;
178  std::unique_ptr<Sock> sock;
179  conn.peer = to;
180 
181  try {
182  {
183  LOCK(m_mutex);
185  session_id = m_session_id;
186  conn.me = m_my_addr;
187  sock = Hello();
188  }
189 
190  const Reply &lookup_reply = SendRequestAndGetReply(
191  *sock, strprintf("NAMING LOOKUP NAME=%s", to.ToStringIP()));
192 
193  const std::string &dest = lookup_reply.Get("VALUE");
194 
195  const Reply &connect_reply = SendRequestAndGetReply(
196  *sock,
197  strprintf("STREAM CONNECT ID=%s DESTINATION=%s SILENT=false",
198  session_id, dest),
199  false);
200 
201  const std::string &result = connect_reply.Get("RESULT");
202 
203  if (result == "OK") {
204  conn.sock = std::move(sock);
205  return true;
206  }
207 
208  if (result == "INVALID_ID") {
209  LOCK(m_mutex);
210  Disconnect();
211  throw std::runtime_error("Invalid session id");
212  }
213 
214  if (result == "CANT_REACH_PEER" || result == "TIMEOUT") {
215  proxy_error = false;
216  }
217 
218  throw std::runtime_error(strprintf("\"%s\"", connect_reply.full));
219  } catch (const std::runtime_error &e) {
220  Log("Error connecting to %s: %s", to.ToString(), e.what());
222  return false;
223  }
224  }
225 
226  // Private methods
227 
228  std::string Session::Reply::Get(const std::string &key) const {
229  const auto &pos = keys.find(key);
230  if (pos == keys.end() || !pos->second.has_value()) {
231  throw std::runtime_error(
232  strprintf("Missing %s= in the reply to \"%s\": \"%s\"", key,
233  request, full));
234  }
235  return pos->second.value();
236  }
237 
238  template <typename... Args>
239  void Session::Log(const std::string &fmt, const Args &...args) const {
240  LogPrint(BCLog::I2P, "I2P: %s\n", tfm::format(fmt, args...));
241  }
242 
244  const std::string &request,
245  bool check_result_ok) const {
246  sock.SendComplete(request + "\n", MAX_WAIT_FOR_IO, *m_interrupt);
247 
248  Reply reply;
249 
250  // Don't log the full "SESSION CREATE ..." because it contains our
251  // private key.
252  reply.request = request.substr(0, 14) == "SESSION CREATE"
253  ? "SESSION CREATE ..."
254  : request;
255 
256  // It could take a few minutes for the I2P router to reply as it is
257  // querying the I2P network (when doing name lookup, for example).
258  // Notice: `RecvUntilTerminator()` is checking `m_interrupt` more often,
259  // so we would not be stuck here for long if `m_interrupt` is signaled.
260  static constexpr auto recv_timeout = 3min;
261 
262  reply.full = sock.RecvUntilTerminator('\n', recv_timeout, *m_interrupt,
263  MAX_MSG_SIZE);
264 
265  for (const auto &kv : spanparsing::Split(reply.full, ' ')) {
266  const auto &pos = std::find(kv.begin(), kv.end(), '=');
267  if (pos != kv.end()) {
268  reply.keys.emplace(std::string{kv.begin(), pos},
269  std::string{pos + 1, kv.end()});
270  } else {
271  reply.keys.emplace(std::string{kv.begin(), kv.end()},
272  std::nullopt);
273  }
274  }
275 
276  if (check_result_ok && reply.Get("RESULT") != "OK") {
277  throw std::runtime_error(strprintf(
278  "Unexpected reply to \"%s\": \"%s\"", request, reply.full));
279  }
280 
281  return reply;
282  }
283 
284  std::unique_ptr<Sock> Session::Hello() const {
285  auto sock = CreateSock(m_control_host);
286 
287  if (!sock) {
288  throw std::runtime_error("Cannot create socket");
289  }
290 
292  true)) {
293  throw std::runtime_error(
294  strprintf("Cannot connect to %s", m_control_host.ToString()));
295  }
296 
297  SendRequestAndGetReply(*sock, "HELLO VERSION MIN=3.1 MAX=3.1");
298 
299  return sock;
300  }
301 
303  LOCK(m_mutex);
304 
305  std::string errmsg;
306  if (!m_control_sock->IsConnected(errmsg)) {
307  Log("Control socket error: %s", errmsg);
308  Disconnect();
309  }
310  }
311 
312  void Session::DestGenerate(const Sock &sock) {
313  // https://geti2p.net/spec/common-structures#key-certificates
314  // "7" or "EdDSA_SHA512_Ed25519" - "Recent Router Identities and
315  // Destinations". Use "7" because i2pd <2.24.0 does not recognize the
316  // textual form.
317  const Reply &reply = SendRequestAndGetReply(
318  sock, "DEST GENERATE SIGNATURE_TYPE=7", false);
319 
320  m_private_key = DecodeI2PBase64(reply.Get("PRIV"));
321  }
322 
324  DestGenerate(sock);
325 
326  // umask is set to 077 in init.cpp, which is ok (unless -sysperms is
327  // given)
328  if (!WriteBinaryFile(
330  std::string(m_private_key.begin(), m_private_key.end()))) {
331  throw std::runtime_error(
332  strprintf("Cannot save I2P private key to %s",
334  }
335  }
336 
338  // From https://geti2p.net/spec/common-structures#destination:
339  // "They are 387 bytes plus the certificate length specified at bytes
340  // 385-386, which may be non-zero"
341  static constexpr size_t DEST_LEN_BASE = 387;
342  static constexpr size_t CERT_LEN_POS = 385;
343 
344  uint16_t cert_len;
345  memcpy(&cert_len, &m_private_key.at(CERT_LEN_POS), sizeof(cert_len));
346  cert_len = be16toh(cert_len);
347 
348  const size_t dest_len = DEST_LEN_BASE + cert_len;
349 
350  return Binary{m_private_key.begin(), m_private_key.begin() + dest_len};
351  }
352 
354  std::string errmsg;
355  if (m_control_sock->IsConnected(errmsg)) {
356  return;
357  }
358 
359  Log("Creating SAM session with %s", m_control_host.ToString());
360 
361  auto sock = Hello();
362 
363  const auto &[read_ok, data] = ReadBinaryFile(m_private_key_file);
364  if (read_ok) {
365  m_private_key.assign(data.begin(), data.end());
366  } else {
368  }
369 
370  const std::string &session_id = GetRandHash().GetHex().substr(
371  0, 10); // full is an overkill, too verbose in the logs
372  const std::string &private_key_b64 =
373  SwapBase64(EncodeBase64(m_private_key));
374 
376  *sock, strprintf("SESSION CREATE STYLE=STREAM ID=%s DESTINATION=%s",
377  session_id, private_key_b64));
378 
380  m_session_id = session_id;
381  m_control_sock = std::move(sock);
382 
383  LogPrintf("I2P: SAM session created: session id=%s, my address=%s\n",
384  m_session_id, m_my_addr.ToString());
385  }
386 
387  std::unique_ptr<Sock> Session::StreamAccept() {
388  auto sock = Hello();
389 
390  const Reply &reply = SendRequestAndGetReply(
391  *sock, strprintf("STREAM ACCEPT ID=%s SILENT=false", m_session_id),
392  false);
393 
394  const std::string &result = reply.Get("RESULT");
395 
396  if (result == "OK") {
397  return sock;
398  }
399 
400  if (result == "INVALID_ID") {
401  // If our session id is invalid, then force session re-creation on
402  // next usage.
403  Disconnect();
404  }
405 
406  throw std::runtime_error(strprintf("\"%s\"", reply.full));
407  }
408 
410  if (m_control_sock->Get() != INVALID_SOCKET) {
411  if (m_session_id.empty()) {
412  Log("Destroying incomplete session");
413  } else {
414  Log("Destroying session %s", m_session_id);
415  }
416  }
417  m_control_sock->Reset();
418  m_session_id.clear();
419  }
420 } // namespace sam
421 } // namespace i2p
Network address.
Definition: netaddress.h:120
std::string ToStringIP() const
Definition: netaddress.cpp:578
bool SetSpecial(const std::string &addr)
Parse a Tor or I2P address and set this object to it.
Definition: netaddress.cpp:227
A hasher class for SHA-256.
Definition: sha256.h:13
CSHA256 & Write(const uint8_t *data, size_t len)
Definition: sha256.cpp:819
static const size_t OUTPUT_SIZE
Definition: sha256.h:20
void Finalize(uint8_t hash[OUTPUT_SIZE])
Definition: sha256.cpp:844
A combination of a network address (CNetAddr) and a (TCP) port.
Definition: netaddress.h:544
std::string ToString() const
uint16_t GetPort() const
Definition: netaddress.cpp:982
A helper class for interruptible sleeps.
RAII helper class that manages a socket.
Definition: sock.h:26
virtual void SendComplete(const std::string &data, std::chrono::milliseconds timeout, CThreadInterrupt &interrupt) const
Send the given data, retrying on transient errors.
Definition: sock.cpp:148
uint8_t Event
Definition: sock.h:116
static constexpr Event RECV
If passed to Wait(), then it will wait for readiness to read from the socket.
Definition: sock.h:122
virtual std::string RecvUntilTerminator(uint8_t terminator, std::chrono::milliseconds timeout, CThreadInterrupt &interrupt, size_t max_data) const
Read from socket until a terminator character is encountered.
Definition: sock.cpp:193
std::string GetHex() const
Definition: uint256.cpp:16
Path class wrapper to prepare application code for transition from boost::filesystem library to std::...
Definition: fs.h:33
const fs::path m_private_key_file
The name of the file where this peer's private key is stored (in binary).
Definition: i2p.h:234
Reply SendRequestAndGetReply(const Sock &sock, const std::string &request, bool check_result_ok=true) const
Send request and get a reply from the SAM proxy.
Definition: i2p.cpp:243
bool Accept(Connection &conn)
Wait for and accept a new incoming connection.
Definition: i2p.cpp:140
void CreateIfNotCreatedAlready() EXCLUSIVE_LOCKS_REQUIRED(m_mutex)
Create the session if not already created.
Definition: i2p.cpp:353
void Disconnect() EXCLUSIVE_LOCKS_REQUIRED(m_mutex)
Destroy the session, closing the internally used sockets.
Definition: i2p.cpp:409
const CService m_control_host
The host and port of the SAM control service.
Definition: i2p.h:239
Session(const fs::path &private_key_file, const CService &control_host, CThreadInterrupt *interrupt)
Construct a session.
Definition: i2p.cpp:115
std::unique_ptr< Sock > Hello() const EXCLUSIVE_LOCKS_REQUIRED(m_mutex)
Open a new connection to the SAM proxy.
Definition: i2p.cpp:284
void CheckControlSock()
Check the control socket for errors and possibly disconnect.
Definition: i2p.cpp:302
std::unique_ptr< Sock > StreamAccept() EXCLUSIVE_LOCKS_REQUIRED(m_mutex)
Open a new connection to the SAM proxy and issue "STREAM ACCEPT" request using the existing session i...
Definition: i2p.cpp:387
bool Listen(Connection &conn)
Start listening for an incoming connection.
Definition: i2p.cpp:126
Binary MyDestination() const EXCLUSIVE_LOCKS_REQUIRED(m_mutex)
Derive own destination from m_private_key.
Definition: i2p.cpp:337
~Session()
Destroy the session, closing the internally used sockets.
Definition: i2p.cpp:121
bool Connect(const CService &to, Connection &conn, bool &proxy_error)
Connect to an I2P peer.
Definition: i2p.cpp:165
void GenerateAndSavePrivateKey(const Sock &sock) EXCLUSIVE_LOCKS_REQUIRED(m_mutex)
Generate a new destination with the SAM proxy, set m_private_key to it and save it on disk to m_priva...
Definition: i2p.cpp:323
CThreadInterrupt *const m_interrupt
Cease network activity when this is signaled.
Definition: i2p.h:244
void DestGenerate(const Sock &sock) EXCLUSIVE_LOCKS_REQUIRED(m_mutex)
Generate a new destination with the SAM proxy and set m_private_key to it.
Definition: i2p.cpp:312
void Log(const std::string &fmt, const Args &...args) const
Log a message in the BCLog::I2P category.
Definition: i2p.cpp:239
Mutex m_mutex
Mutex protecting the members that can be concurrently accessed.
Definition: i2p.h:249
#define INVALID_SOCKET
Definition: compat.h:52
uint16_t be16toh(uint16_t big_endian_16bits)
Definition: endian.h:156
#define LogPrint(category,...)
Definition: logging.h:208
#define LogPrintf(...)
Definition: logging.h:204
@ I2P
Definition: logging.h:62
static auto quoted(const std::string &s)
Definition: fs.h:99
static std::string PathToString(const path &path)
Convert path object to byte string.
Definition: fs.h:134
static constexpr size_t MAX_MSG_SIZE
The maximum size of an incoming message from the I2P SAM proxy (in bytes).
Definition: i2p.h:52
Definition: i2p.cpp:28
static CNetAddr DestB64ToAddr(const std::string &dest)
Derive the .b32.i2p address of an I2P destination (I2P-style Base64).
Definition: i2p.cpp:108
static std::string SwapBase64(const std::string &from)
Swap Standard Base64 <-> I2P Base64.
Definition: i2p.cpp:38
static CNetAddr DestBinToAddr(const Binary &dest)
Derive the .b32.i2p address of an I2P destination (binary).
Definition: i2p.cpp:86
std::vector< uint8_t > Binary
Binary data.
Definition: i2p.h:26
static Binary DecodeI2PBase64(const std::string &i2p_b64)
Decode an I2P-style Base64 string.
Definition: i2p.cpp:69
std::vector< Span< const char > > Split(const Span< const char > &sp, char sep)
Split a string on every instance of sep, returning a vector.
Definition: spanparsing.cpp:51
void format(std::ostream &out, const char *fmt, const Args &...args)
Format list of arguments to the stream according to given format string.
Definition: tinyformat.h:1111
static constexpr uint16_t I2P_SAM31_PORT
SAM 3.1 and earlier do not support specifying ports and force the port to 0.
Definition: netaddress.h:115
bool ConnectSocketDirectly(const CService &addrConnect, const Sock &sock, int nTimeout, bool manual_connection)
Try to connect to the specified service on the specified socket.
Definition: netbase.cpp:634
std::function< std::unique_ptr< Sock >const CService &)> CreateSock
Socket factory.
Definition: netbase.cpp:620
int nConnectTimeout
Definition: netbase.cpp:37
uint256 GetRandHash() noexcept
Definition: random.cpp:658
std::pair< bool, std::string > ReadBinaryFile(const fs::path &filename, size_t maxsize=std::numeric_limits< size_t >::max())
Read full contents of a file and return them in a std::string.
bool WriteBinaryFile(const fs::path &filename, const std::string &data)
Write contents of std::string to a file.
static constexpr auto MAX_WAIT_FOR_IO
Maximum time to wait for I/O readiness.
Definition: sock.h:19
std::string EncodeBase64(Span< const uint8_t > input)
std::string EncodeBase32(Span< const uint8_t > input, bool pad)
Base32 encode.
std::vector< uint8_t > DecodeBase64(const char *p, bool *pf_invalid)
An established connection with another peer.
Definition: i2p.h:31
std::unique_ptr< Sock > sock
Connected socket.
Definition: i2p.h:33
CService me
Our I2P address.
Definition: i2p.h:36
CService peer
The peer's I2P address.
Definition: i2p.h:39
A reply from the SAM proxy.
Definition: i2p.h:118
std::string Get(const std::string &key) const
Get the value of a given key.
Definition: i2p.cpp:228
std::string full
Full, unparsed reply.
Definition: i2p.h:122
std::unordered_map< std::string, std::optional< std::string > > keys
A map of keywords from the parsed reply.
Definition: i2p.h:136
std::string request
Request, used for detailed error reporting.
Definition: i2p.h:127
#define LOCK(cs)
Definition: sync.h:243
#define strprintf
Format arguments and return the string or write to given std::ostream (see tinyformat::format doc for...
Definition: tinyformat.h:1201