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 <netaddress.h>
12#include <netbase.h>
13#include <random.h>
14#include <script/parsing.h>
15#include <sync.h>
16#include <tinyformat.h>
17#include <util/fs.h>
18#include <util/log.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
30using util::Split;
31
32namespace 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 */
42static 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 */
74static 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 */
90static 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 */
112static CNetAddr DestB64ToAddr(const std::string& dest)
113{
114    const Binary& decoded = DecodeI2PBase64(dest);
115    return DestBinToAddr(decoded);
116}
117
118namespace sam {
119
120Session::Session(const fs::path& private_key_file,
121                 const Proxy& control_host,
122                 std::shared_ptr<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
130Session::Session(const Proxy& control_host, std::shared_ptr<CThreadInterrupt> interrupt)
131    : m_control_host{control_host},
132      m_interrupt{interrupt},
133      m_transient{true}
134{
135}
136
137Session::~Session()
138{
139    LOCK(m_mutex);
140    Disconnect();
141}
142
143bool 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        LogError("Couldn't listen: %s\n", e.what());
153        CheckControlSock();
154    }
155    return false;
156}
157
158bool Session::Accept(Connection& conn)
159{
160    AssertLockNotHeld(m_mutex);
161
162    std::string errmsg;
163    bool disconnect{false};
164
165    while (!m_interrupt->interrupted()) {
166        Sock::Event occurred;
167        if (!conn.sock->Wait(MAX_WAIT_FOR_IO, Sock::RecvEvent, &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->interrupted()) {
209        LogDebug(BCLog::I2P, "Accept was interrupted\n");
210    } else {
211        LogDebug(BCLog::I2P, "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
222bool 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        LogDebug(BCLog::I2P, "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");