LCOV - code coverage report
Current view: top level - src - i2p.cpp (source / functions) Coverage Total Hit
Test: total_coverage.info Lines: 77.9 % 262 204
Test Date: 2025-03-28 05:06:44 Functions: 100.0 % 20 20
Branches: 41.6 % 409 170

             Branch data     Line data    Source code
       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                 :          16 : static std::string SwapBase64(const std::string& from)
      43                 :             : {
      44         [ +  - ]:          16 :     std::string to;
      45         [ +  - ]:          16 :     to.resize(from.size());
      46         [ +  + ]:        7323 :     for (size_t i = 0; i < from.size(); ++i) {
      47   [ +  +  +  +  :        7307 :         switch (from[i]) {
                      + ]
      48                 :           8 :         case '-':
      49                 :           8 :             to[i] = '+';
      50                 :           8 :             break;
      51                 :          22 :         case '~':
      52                 :          22 :             to[i] = '/';
      53                 :          22 :             break;
      54                 :          40 :         case '+':
      55                 :          40 :             to[i] = '-';
      56                 :          40 :             break;
      57                 :         110 :         case '/':
      58                 :         110 :             to[i] = '~';
      59                 :         110 :             break;
      60                 :        7127 :         default:
      61                 :        7127 :             to[i] = from[i];
      62                 :        7127 :             break;
      63                 :             :         }
      64                 :             :     }
      65                 :          16 :     return to;
      66                 :           0 : }
      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                 :           6 : static Binary DecodeI2PBase64(const std::string& i2p_b64)
      75                 :             : {
      76                 :           6 :     const std::string& std_b64 = SwapBase64(i2p_b64);
      77         [ +  - ]:           6 :     auto decoded = DecodeBase64(std_b64);
      78         [ +  + ]:           6 :     if (!decoded) {
      79   [ +  -  +  - ]:          10 :         throw std::runtime_error(strprintf("Cannot decode Base64: \"%s\"", i2p_b64));
      80                 :             :     }
      81                 :           1 :     return std::move(*decoded);
      82                 :           6 : }
      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                 :           5 : static CNetAddr DestBinToAddr(const Binary& dest)
      91                 :             : {
      92                 :           5 :     CSHA256 hasher;
      93                 :           5 :     hasher.Write(dest.data(), dest.size());
      94                 :           5 :     unsigned char hash[CSHA256::OUTPUT_SIZE];
      95                 :           5 :     hasher.Finalize(hash);
      96                 :             : 
      97                 :           5 :     CNetAddr addr;
      98         [ +  - ]:          10 :     const std::string addr_str = EncodeBase32(hash, false) + ".b32.i2p";
      99   [ +  -  -  + ]:           5 :     if (!addr.SetSpecial(addr_str)) {
     100   [ #  #  #  # ]:           0 :         throw std::runtime_error(strprintf("Cannot parse I2P address: \"%s\"", addr_str));
     101                 :             :     }
     102                 :             : 
     103                 :           5 :     return addr;
     104                 :           5 : }
     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                 :           5 : static CNetAddr DestB64ToAddr(const std::string& dest)
     113                 :             : {
     114                 :           5 :     const Binary& decoded = DecodeI2PBase64(dest);
     115         [ #  # ]:           0 :     return DestBinToAddr(decoded);
     116                 :           0 : }
     117                 :             : 
     118                 :             : namespace sam {
     119                 :             : 
     120                 :          11 : Session::Session(const fs::path& private_key_file,
     121                 :             :                  const Proxy& control_host,
     122                 :          11 :                  CThreadInterrupt* interrupt)
     123                 :          11 :     : m_private_key_file{private_key_file},
     124         [ +  - ]:          11 :       m_control_host{control_host},
     125                 :          11 :       m_interrupt{interrupt},
     126         [ +  - ]:          11 :       m_transient{false}
     127                 :             : {
     128                 :          11 : }
     129                 :             : 
     130                 :           1 : Session::Session(const Proxy& control_host, CThreadInterrupt* interrupt)
     131                 :           0 :     : m_control_host{control_host},
     132                 :           1 :       m_interrupt{interrupt},
     133   [ +  -  +  - ]:           1 :       m_transient{true}
     134                 :             : {
     135                 :           1 : }
     136                 :             : 
     137                 :          12 : Session::~Session()
     138                 :             : {
     139                 :          12 :     LOCK(m_mutex);
     140         [ +  - ]:          12 :     Disconnect();
     141                 :          24 : }
     142                 :             : 
     143                 :           9 : bool Session::Listen(Connection& conn)
     144                 :             : {
     145                 :           9 :     try {
     146         [ +  - ]:           9 :         LOCK(m_mutex);
     147         [ +  + ]:           9 :         CreateIfNotCreatedAlready();
     148                 :           5 :         conn.me = m_my_addr;
     149         [ +  - ]:           5 :         conn.sock = StreamAccept();
     150         [ +  - ]:           5 :         return true;
     151         [ -  + ]:           9 :     } catch (const std::runtime_error& e) {
     152   [ +  -  +  -  :           4 :         LogPrintLevel(BCLog::I2P, BCLog::Level::Error, "Couldn't listen: %s\n", e.what());
                   +  - ]
     153         [ +  - ]:           4 :         CheckControlSock();
     154                 :           0 :     }
     155                 :           4 :     return false;
     156                 :             : }
     157                 :             : 
     158                 :           5 : bool Session::Accept(Connection& conn)
     159                 :             : {
     160                 :           5 :     AssertLockNotHeld(m_mutex);
     161                 :             : 
     162                 :           5 :     std::string errmsg;
     163                 :           5 :     bool disconnect{false};
     164                 :             : 
     165   [ +  -  +  - ]:           5 :     while (!*m_interrupt) {
     166                 :           5 :         Sock::Event occurred;
     167   [ +  -  -  + ]:           5 :         if (!conn.sock->Wait(MAX_WAIT_FOR_IO, Sock::RECV, &occurred)) {
     168         [ #  # ]:           0 :             errmsg = "wait on socket failed";
     169                 :             :             break;
     170                 :             :         }
     171                 :             : 
     172         [ -  + ]:           5 :         if (occurred == 0) {
     173                 :             :             // Timeout, no incoming connections or errors within MAX_WAIT_FOR_IO.
     174                 :           0 :             continue;
     175                 :             :         }
     176                 :             : 
     177                 :           5 :         std::string peer_dest;
     178                 :           5 :         try {
     179         [ +  - ]:           5 :             peer_dest = conn.sock->RecvUntilTerminator('\n', MAX_WAIT_FOR_IO, *m_interrupt, MAX_MSG_SIZE);
     180         [ -  - ]:           0 :         } catch (const std::runtime_error& e) {
     181         [ -  - ]:           0 :             errmsg = e.what();
     182                 :           0 :             break;
     183                 :           0 :         }
     184                 :             : 
     185         [ +  - ]:           5 :         CNetAddr peer_addr;
     186                 :           5 :         try {
     187         [ -  + ]:           5 :             peer_addr = DestB64ToAddr(peer_dest);
     188         [ -  + ]:           5 :         } 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         [ +  - ]:           5 :             if (peer_dest.find("RESULT=I2P_ERROR") != std::string::npos) {
     195         [ +  - ]:           5 :                 errmsg = strprintf("unexpected reply that hints the session is unusable: %s", peer_dest);
     196                 :           5 :                 disconnect = true;
     197                 :             :             } else {
     198         [ -  - ]:           0 :                 errmsg = e.what();
     199                 :             :             }
     200                 :           5 :             break;
     201                 :           5 :         }
     202                 :             : 
     203         [ #  # ]:           0 :         conn.peer = CService(peer_addr, I2P_SAM31_PORT);
     204                 :             : 
     205                 :           0 :         return true;
     206                 :          10 :     }
     207                 :             : 
     208   [ +  -  -  + ]:           5 :     if (*m_interrupt) {
     209   [ #  #  #  #  :           0 :         LogPrintLevel(BCLog::I2P, BCLog::Level::Debug, "Accept was interrupted\n");
                   #  # ]
     210                 :             :     } else {
     211   [ +  -  +  -  :           5 :         LogPrintLevel(BCLog::I2P, BCLog::Level::Debug, "Error accepting%s: %s\n", disconnect ? " (will close the session)" : "", errmsg);
             -  +  +  - ]
     212                 :             :     }
     213         [ +  - ]:           5 :     if (disconnect) {
     214         [ +  - ]:           5 :         LOCK(m_mutex);
     215         [ +  - ]:           5 :         Disconnect();
     216                 :           5 :     } else {
     217         [ #  # ]:           0 :         CheckControlSock();
     218                 :             :     }
     219                 :             :     return false;
     220                 :           5 : }
     221                 :             : 
     222                 :          10 : 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         [ +  + ]:          10 :     if (to.GetPort() != I2P_SAM31_PORT) {
     227   [ +  -  +  - ]:           2 :         LogPrintLevel(BCLog::I2P, BCLog::Level::Debug, "Error connecting to %s, connection refused due to arbitrary port %s\n", to.ToStringAddrPort(), to.GetPort());
     228                 :           1 :         proxy_error = false;
     229                 :           1 :         return false;
     230                 :             :     }
     231                 :             : 
     232                 :           9 :     proxy_error = true;
     233                 :             : 
     234                 :           9 :     std::string session_id;
     235                 :           9 :     std::unique_ptr<Sock> sock;
     236                 :           9 :     conn.peer = to;
     237                 :             : 
     238                 :           9 :     try {
     239                 :           9 :         {
     240         [ +  - ]:           9 :             LOCK(m_mutex);
     241         [ -  + ]:           9 :             CreateIfNotCreatedAlready();
     242         [ #  # ]:           0 :             session_id = m_session_id;
     243                 :           0 :             conn.me = m_my_addr;
     244   [ #  #  #  # ]:           0 :             sock = Hello();
     245                 :           9 :         }
     246                 :             : 
     247                 :           0 :         const Reply& lookup_reply =
     248   [ #  #  #  #  :           0 :             SendRequestAndGetReply(*sock, strprintf("NAMING LOOKUP NAME=%s", to.ToStringAddr()));
                   #  # ]
     249                 :             : 
     250   [ #  #  #  # ]:           0 :         const std::string& dest = lookup_reply.Get("VALUE");
     251                 :             : 
     252                 :           0 :         const Reply& connect_reply = SendRequestAndGetReply(
     253         [ #  # ]:           0 :             *sock, strprintf("STREAM CONNECT ID=%s DESTINATION=%s SILENT=false", session_id, dest),
     254         [ #  # ]:           0 :             false);
     255                 :             : 
     256   [ #  #  #  # ]:           0 :         const std::string& result = connect_reply.Get("RESULT");
     257                 :             : 
     258         [ #  # ]:           0 :         if (result == "OK") {
     259                 :           0 :             conn.sock = std::move(sock);
     260                 :           0 :             return true;
     261                 :             :         }
     262                 :             : 
     263         [ #  # ]:           0 :         if (result == "INVALID_ID") {
     264         [ #  # ]:           0 :             LOCK(m_mutex);
     265         [ #  # ]:           0 :             Disconnect();
     266         [ #  # ]:           0 :             throw std::runtime_error("Invalid session id");
     267                 :           0 :         }
     268                 :             : 
     269   [ #  #  #  # ]:           0 :         if (result == "CANT_REACH_PEER" || result == "TIMEOUT") {
     270                 :           0 :             proxy_error = false;
     271                 :             :         }
     272                 :             : 
     273   [ #  #  #  # ]:           0 :         throw std::runtime_error(strprintf("\"%s\"", connect_reply.full));
     274         [ -  + ]:           9 :     } catch (const std::runtime_error& e) {
     275   [ +  -  +  -  :          18 :         LogPrintLevel(BCLog::I2P, BCLog::Level::Debug, "Error connecting to %s: %s\n", to.ToStringAddrPort(), e.what());
             +  -  +  - ]
     276         [ +  - ]:           9 :         CheckControlSock();
     277                 :           9 :         return false;
     278                 :           9 :     }
     279                 :           9 : }
     280                 :             : 
     281                 :             : // Private methods
     282                 :             : 
     283                 :          31 : std::string Session::Reply::Get(const std::string& key) const
     284                 :             : {
     285                 :          31 :     const auto& pos = keys.find(key);
     286   [ +  -  -  + ]:          31 :     if (pos == keys.end() || !pos->second.has_value()) {
     287                 :           0 :         throw std::runtime_error(
     288   [ #  #  #  # ]:           0 :             strprintf("Missing %s= in the reply to \"%s\": \"%s\"", key, request, full));
     289                 :             :     }
     290                 :          31 :     return pos->second.value();
     291                 :             : }
     292                 :             : 
     293                 :          32 : Session::Reply Session::SendRequestAndGetReply(const Sock& sock,
     294                 :             :                                                const std::string& request,
     295                 :             :                                                bool check_result_ok) const
     296                 :             : {
     297         [ +  - ]:          32 :     sock.SendComplete(request + "\n", MAX_WAIT_FOR_IO, *m_interrupt);
     298                 :             : 
     299         [ +  - ]:          32 :     Reply reply;
     300                 :             : 
     301                 :             :     // Don't log the full "SESSION CREATE ..." because it contains our private key.
     302   [ +  -  +  +  :          64 :     reply.request = request.substr(0, 14) == "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                 :          32 :     static constexpr auto recv_timeout = 3min;
     309                 :             : 
     310         [ +  + ]:          32 :     reply.full = sock.RecvUntilTerminator('\n', recv_timeout, *m_interrupt, MAX_MSG_SIZE);
     311                 :             : 
     312   [ +  -  +  + ]:         145 :     for (const auto& kv : Split(reply.full, ' ')) {
     313                 :         114 :         const auto pos{std::ranges::find(kv, '=')};
     314         [ +  + ]:         114 :         if (pos != kv.end()) {
     315   [ +  -  +  -  :         156 :             reply.keys.emplace(std::string{kv.begin(), pos}, std::string{pos + 1, kv.end()});
                   +  - ]
     316                 :             :         } else {
     317   [ +  -  +  - ]:         124 :             reply.keys.emplace(std::string{kv.begin(), kv.end()}, std::nullopt);
     318                 :             :         }
     319                 :           0 :     }
     320                 :             : 
     321   [ +  +  +  -  :          81 :     if (check_result_ok && reply.Get("RESULT") != "OK") {
          +  -  -  +  +  
             +  -  +  -  
                      - ]
     322                 :           0 :         throw std::runtime_error(
     323   [ #  #  #  # ]:           0 :             strprintf("Unexpected reply to \"%s\": \"%s\"", request, reply.full));
     324                 :             :     }
     325                 :             : 
     326                 :          31 :     return reply;
     327                 :           1 : }
     328                 :             : 
     329                 :          23 : std::unique_ptr<Sock> Session::Hello() const
     330                 :             : {
     331                 :          23 :     auto sock = m_control_host.Connect();
     332                 :             : 
     333         [ +  + ]:          23 :     if (!sock) {
     334   [ +  -  +  -  :          14 :         throw std::runtime_error(strprintf("Cannot connect to %s", m_control_host.ToString()));
                   +  - ]
     335                 :             :     }
     336                 :             : 
     337   [ +  -  +  + ]:          17 :     SendRequestAndGetReply(*sock, "HELLO VERSION MIN=3.1 MAX=3.1");
     338                 :             : 
     339                 :          15 :     return sock;
     340                 :           8 : }
     341                 :             : 
     342                 :          13 : void Session::CheckControlSock()
     343                 :             : {
     344                 :          13 :     LOCK(m_mutex);
     345                 :             : 
     346         [ -  + ]:          13 :     std::string errmsg;
     347   [ -  +  -  -  :          13 :     if (m_control_sock && !m_control_sock->IsConnected(errmsg)) {
                   -  - ]
     348   [ #  #  #  #  :           0 :         LogPrintLevel(BCLog::I2P, BCLog::Level::Debug, "Control socket error: %s\n", errmsg);
                   #  # ]
     349         [ #  # ]:           0 :         Disconnect();
     350                 :             :     }
     351         [ +  - ]:          26 : }
     352                 :             : 
     353                 :           1 : 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         [ +  - ]:           1 :     const Reply& reply = SendRequestAndGetReply(sock, "DEST GENERATE SIGNATURE_TYPE=7", false);
     360                 :             : 
     361   [ +  -  +  -  :           1 :     m_private_key = DecodeI2PBase64(reply.Get("PRIV"));
                   +  - ]
     362                 :           1 : }
     363                 :             : 
     364                 :           1 : void Session::GenerateAndSavePrivateKey(const Sock& sock)
     365                 :             : {
     366                 :           1 :     DestGenerate(sock);
     367                 :             : 
     368                 :             :     // umask is set to 0077 in common/system.cpp, which is ok.
     369                 :           2 :     if (!WriteBinaryFile(m_private_key_file,
     370   [ +  -  -  + ]:           2 :                          std::string(m_private_key.begin(), m_private_key.end()))) {
     371                 :           0 :         throw std::runtime_error(
     372   [ #  #  #  #  :           0 :             strprintf("Cannot save I2P private key to %s", fs::quoted(fs::PathToString(m_private_key_file))));
                   #  # ]
     373                 :             :     }
     374                 :           1 : }
     375                 :             : 
     376                 :          10 : 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                 :          10 :     static constexpr size_t DEST_LEN_BASE = 387;
     382                 :          10 :     static constexpr size_t CERT_LEN_POS = 385;
     383                 :             : 
     384                 :          10 :     uint16_t cert_len;
     385                 :             : 
     386         [ +  + ]:          10 :     if (m_private_key.size() < CERT_LEN_POS + sizeof(cert_len)) {
     387         [ +  - ]:           3 :         throw std::runtime_error(strprintf("The private key is too short (%d < %d)",
     388                 :           3 :                                            m_private_key.size(),
     389   [ +  -  +  - ]:           6 :                                            CERT_LEN_POS + sizeof(cert_len)));
     390                 :             :     }
     391                 :             : 
     392         [ +  + ]:           7 :     memcpy(&cert_len, &m_private_key.at(CERT_LEN_POS), sizeof(cert_len));
     393         [ +  + ]:           7 :     cert_len = be16toh_internal(cert_len);
     394                 :             : 
     395                 :           7 :     const size_t dest_len = DEST_LEN_BASE + cert_len;
     396                 :             : 
     397         [ +  + ]:           7 :     if (dest_len > m_private_key.size()) {
     398         [ +  - ]:           2 :         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   [ +  -  +  - ]:           4 :                                            m_private_key.size()));
     403                 :             :     }
     404                 :             : 
     405                 :           5 :     return Binary{m_private_key.begin(), m_private_key.begin() + dest_len};
     406                 :             : }
     407                 :             : 
     408                 :          18 : void Session::CreateIfNotCreatedAlready()
     409                 :             : {
     410         [ -  + ]:          18 :     std::string errmsg;
     411   [ -  +  -  -  :          18 :     if (m_control_sock && m_control_sock->IsConnected(errmsg)) {
                   -  - ]
     412                 :           0 :         return;
     413                 :             :     }
     414                 :             : 
     415         [ +  + ]:          18 :     const auto session_type = m_transient ? "transient" : "persistent";
     416   [ +  -  +  - ]:          18 :     const auto session_id = GetRandHash().GetHex().substr(0, 10); // full is overkill, too verbose in the logs
     417                 :             : 
     418   [ +  -  +  -  :          36 :     LogPrintLevel(BCLog::I2P, BCLog::Level::Debug, "Creating %s SAM session %s with %s\n", session_type, session_id, m_control_host.ToString());
             +  -  +  - ]
     419                 :             : 
     420         [ +  + ]:          18 :     auto sock = Hello();
     421                 :             : 
     422         [ -  + ]:          10 :     if (m_transient) {
     423                 :             :         // The destination (private key) is generated upon session creation and returned
     424                 :             :         // in the reply in DESTINATION=.
     425                 :           0 :         const Reply& reply = SendRequestAndGetReply(
     426                 :           0 :             *sock,
     427         [ #  # ]:           0 :             strprintf("SESSION CREATE STYLE=STREAM ID=%s DESTINATION=TRANSIENT SIGNATURE_TYPE=7 "
     428                 :             :                       "i2cp.leaseSetEncType=4,0 inbound.quantity=1 outbound.quantity=1",
     429         [ #  # ]:           0 :                       session_id));
     430                 :             : 
     431   [ #  #  #  #  :           0 :         m_private_key = DecodeI2PBase64(reply.Get("DESTINATION"));
                   #  # ]
     432                 :           0 :     } 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   [ +  -  +  + ]:          10 :         const auto& [read_ok, data] = ReadBinaryFile(m_private_key_file);
     436         [ +  + ]:          10 :         if (read_ok) {
     437         [ +  - ]:           9 :             m_private_key.assign(data.begin(), data.end());
     438                 :             :         } else {
     439         [ +  - ]:           1 :             GenerateAndSavePrivateKey(*sock);
     440                 :             :         }
     441                 :             : 
     442   [ +  -  +  - ]:          10 :         const std::string& private_key_b64 = SwapBase64(EncodeBase64(m_private_key));
     443                 :             : 
     444         [ +  - ]:          10 :         SendRequestAndGetReply(*sock,
     445         [ +  - ]:          20 :                                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                 :          10 :     }
     450                 :             : 
     451   [ +  +  +  -  :          10 :     m_my_addr = CService(DestBinToAddr(MyDestination()), I2P_SAM31_PORT);
                   +  - ]
     452         [ +  - ]:           5 :     m_session_id = session_id;
     453                 :           5 :     m_control_sock = std::move(sock);
     454                 :             : 
     455   [ +  -  +  -  :          10 :     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                 :          23 : }
     460                 :             : 
     461                 :           5 : std::unique_ptr<Sock> Session::StreamAccept()
     462                 :             : {
     463                 :           5 :     auto sock = Hello();
     464                 :             : 
     465                 :           5 :     const Reply& reply = SendRequestAndGetReply(
     466   [ +  -  +  - ]:           5 :         *sock, strprintf("STREAM ACCEPT ID=%s SILENT=false", m_session_id), false);
     467                 :             : 
     468   [ +  -  +  - ]:           5 :     const std::string& result = reply.Get("RESULT");
     469                 :             : 
     470         [ +  - ]:           5 :     if (result == "OK") {
     471                 :          10 :         return sock;
     472                 :             :     }
     473                 :             : 
     474         [ #  # ]:           0 :     if (result == "INVALID_ID") {
     475                 :             :         // If our session id is invalid, then force session re-creation on next usage.
     476         [ #  # ]:           0 :         Disconnect();
     477                 :             :     }
     478                 :             : 
     479   [ #  #  #  # ]:           0 :     throw std::runtime_error(strprintf("\"%s\"", reply.full));
     480                 :           5 : }
     481                 :             : 
     482                 :          17 : void Session::Disconnect()
     483                 :             : {
     484         [ +  + ]:          17 :     if (m_control_sock) {
     485         [ -  + ]:           5 :         if (m_session_id.empty()) {
     486         [ #  # ]:           0 :             LogPrintLevel(BCLog::I2P, BCLog::Level::Info, "Destroying incomplete SAM session\n");
     487                 :             :         } else {
     488         [ +  - ]:           5 :             LogPrintLevel(BCLog::I2P, BCLog::Level::Info, "Destroying SAM session %s\n", m_session_id);
     489                 :             :         }
     490         [ +  - ]:           5 :         m_control_sock.reset();
     491                 :             :     }
     492                 :          17 :     m_session_id.clear();
     493                 :          17 : }
     494                 :             : } // namespace sam
     495                 :             : } // namespace i2p
        

Generated by: LCOV version 2.0-1