Ton

1
/*
2
    This file is part of TON Blockchain Library.
3

4
    TON Blockchain Library is free software: you can redistribute it and/or modify
5
    it under the terms of the GNU Lesser General Public License as published by
6
    the Free Software Foundation, either version 2 of the License, or
7
    (at your option) any later version.
8

9
    TON Blockchain Library is distributed in the hope that it will be useful,
10
    but WITHOUT ANY WARRANTY; without even the implied warranty of
11
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12
    GNU Lesser General Public License for more details.
13

14
    You should have received a copy of the GNU Lesser General Public License
15
    along with TON Blockchain Library.  If not, see <http://www.gnu.org/licenses/>.
16

17
    Copyright 2017-2020 Telegram Systems LLP
18
*/
19
#include "adnl-channel.hpp"
20
#include "adnl-peer.h"
21
#include "adnl-peer-table.h"
22

23
#include "td/utils/crypto.h"
24
#include "crypto/Ed25519.h"
25

26
namespace ton {
27

28
namespace adnl {
29

30
td::Result<td::actor::ActorOwn<AdnlChannel>> AdnlChannel::create(privkeys::Ed25519 pk_data, pubkeys::Ed25519 pub_data,
31
                                                                 AdnlNodeIdShort local_id, AdnlNodeIdShort peer_id,
32
                                                                 AdnlChannelIdShort &out_id, AdnlChannelIdShort &in_id,
33
                                                                 td::actor::ActorId<AdnlPeerPair> peer_pair) {
34
  td::Ed25519::PublicKey pub_k = pub_data.export_key();
35
  td::Ed25519::PrivateKey priv_k = pk_data.export_key();
36

37
  TRY_RESULT_PREFIX(shared_secret, td::Ed25519::compute_shared_secret(pub_k, priv_k),
38
                    "failed to compute channel shared secret: ");
39
  CHECK(shared_secret.length() == 32);
40

41
  td::SecureString rev_secret{32};
42
  for (td::uint32 i = 0; i < 32; i++) {
43
    rev_secret.as_mutable_slice()[i] = shared_secret[31 - i];
44
  }
45

46
  auto R = [&]() -> std::pair<PrivateKey, PublicKey> {
47
    if (local_id < peer_id) {
48
      return {privkeys::AES{std::move(shared_secret)}, pubkeys::AES{std::move(rev_secret)}};
49
    } else if (peer_id < local_id) {
50
      return {privkeys::AES{std::move(rev_secret)}, pubkeys::AES{std::move(shared_secret)}};
51
    } else {
52
      auto c = shared_secret.copy();
53
      return {privkeys::AES{std::move(c)}, pubkeys::AES{std::move(shared_secret)}};
54
    }
55
  }();
56

57
  in_id = AdnlChannelIdShort{R.first.compute_short_id()};
58
  out_id = AdnlChannelIdShort{R.second.compute_short_id()};
59

60
  TRY_RESULT_PREFIX(encryptor, R.second.create_encryptor(), "failed to init channel encryptor: ");
61
  TRY_RESULT_PREFIX(decryptor, R.first.create_decryptor(), "failed to init channel decryptor: ");
62

63
  return td::actor::create_actor<AdnlChannelImpl>("channel", local_id, peer_id, peer_pair, in_id, out_id,
64
                                                  std::move(encryptor), std::move(decryptor));
65
}
66

67
AdnlChannelImpl::AdnlChannelImpl(AdnlNodeIdShort local_id, AdnlNodeIdShort peer_id,
68
                                 td::actor::ActorId<AdnlPeerPair> peer_pair, AdnlChannelIdShort in_id,
69
                                 AdnlChannelIdShort out_id, std::unique_ptr<Encryptor> encryptor,
70
                                 std::unique_ptr<Decryptor> decryptor) {
71
  local_id_ = local_id;
72
  peer_id_ = peer_id;
73

74
  encryptor_ = std::move(encryptor);
75
  decryptor_ = std::move(decryptor);
76

77
  channel_in_id_ = in_id;
78
  channel_out_id_ = out_id;
79

80
  peer_pair_ = peer_pair;
81

82
  VLOG(ADNL_INFO) << this << ": created";
83
}
84

85
void AdnlChannelImpl::decrypt(td::BufferSlice raw_data, td::Promise<AdnlPacket> promise) {
86
  TRY_RESULT_PROMISE_PREFIX(promise, data, decryptor_->decrypt(raw_data.as_slice()),
87
                            "failed to decrypt channel message: ");
88
  TRY_RESULT_PROMISE_PREFIX(promise, tl_packet, fetch_tl_object<ton_api::adnl_packetContents>(std::move(data), true),
89
                            "decrypted channel packet contains invalid TL scheme: ");
90
  TRY_RESULT_PROMISE_PREFIX(promise, packet, AdnlPacket::create(std::move(tl_packet)), "received bad packet: ");
91
  if (packet.inited_from_short() && packet.from_short() != peer_id_) {
92
    promise.set_error(td::Status::Error(ErrorCode::protoviolation, "bad channel packet destination"));
93
    return;
94
  }
95
  promise.set_value(std::move(packet));
96
}
97

98
void AdnlChannelImpl::send_message(td::uint32 priority, td::actor::ActorId<AdnlNetworkConnection> conn,
99
                                   td::BufferSlice data) {
100
  auto E = encryptor_->encrypt(data.as_slice());
101
  if (E.is_error()) {
102
    VLOG(ADNL_ERROR) << this << ": dropping OUT message: can not encrypt: " << E.move_as_error();
103
    return;
104
  }
105
  auto enc = E.move_as_ok();
106
  auto B = td::BufferSlice(enc.size() + 32);
107
  td::MutableSlice S = B.as_slice();
108
  S.copy_from(channel_out_id_.as_slice());
109
  S.remove_prefix(32);
110
  S.copy_from(enc.as_slice());
111
  td::actor::send_closure(conn, &AdnlNetworkConnection::send, local_id_, peer_id_, priority, std::move(B));
112
}
113

114
void AdnlChannelImpl::receive(td::IPAddress addr, td::BufferSlice data) {
115
  auto P = td::PromiseCreator::lambda(
116
      [peer = peer_pair_, channel_id = channel_in_id_, addr, id = print_id()](td::Result<AdnlPacket> R) {
117
        if (R.is_error()) {
118
          VLOG(ADNL_WARNING) << id << ": dropping IN message: can not decrypt: " << R.move_as_error();
119
        } else {
120
          auto packet = R.move_as_ok();
121
          packet.set_remote_addr(addr);
122
          td::actor::send_closure(peer, &AdnlPeerPair::receive_packet_from_channel, channel_id, std::move(packet));
123
        }
124
      });
125

126
  decrypt(std::move(data), std::move(P));
127
}
128

129
}  // namespace adnl
130

131
}  // namespace ton
132