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        LogDebug(BCLog::I2P, "Error connecting to %s: %s\n", to.ToStringAddrPort(), e.what());
276        CheckControlSock();
277        return false;
278    }
279}
280
281// Private methods
282
283std::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\"", key, request));
289    }
290    return pos->second.value();
291}
292
293Session::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("Reply to \"%s\": had a RESULT not equal to OK.", reply.request));
324    }
325
326    return reply;
327}
328
329std::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
342void Session::CheckControlSock()
343{
344    LOCK(m_mutex);
345
346    std::string errmsg;
347    if (m_control_sock && !m_control_sock->IsConnected(errmsg)) {
348        LogDebug(BCLog::I2P, "Control socket error: %s\n", errmsg);
349        Disconnect();
350    }
351}
352
353void Session::DestGenerate(const Sock& sock)
354{
355    // https://i2p.net/en/docs/specs/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
364void 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
376Binary Session::MyDestination() const
377{
378    // From https://i2p.net/en/docs/specs/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
408void 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    LogDebug(BCLog::I2P, "Creating %s I2P 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    LogInfo("%s I2P SAM session %s created, my address=%s",
456        Capitalize(session_type),
457        m_session_id,
458        m_my_addr.ToStringAddrPort());
459}
460
461std::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
482void Session::Disconnect()
483{
484    if (m_control_sock) {
485        if (m_session_id.empty()) {
486            LogInfo("Destroying incomplete I2P SAM session");
487        } else {
488            LogInfo("Destroying I2P SAM session %s", m_session_id);
489        }
490        m_control_sock.reset();
491    }
492    m_session_id.clear();
493}
494} // namespace sam
495} // namespace i2p
496