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