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-proxy-types.hpp"
20
#include "tl-utils/tl-utils.hpp"
21
#include "auto/tl/ton_api.hpp"
22
#include "td/utils/overloaded.h"
23
#include "td/utils/Time.h"
24
#include "common/errorcode.h"
25

26
namespace ton {
27

28
namespace adnl {
29

30
td::Result<AdnlProxy::Packet> AdnlProxyNone::decrypt(td::BufferSlice packet) const {
31
  if (packet.size() < 32) {
32
    return td::Status::Error(ErrorCode::protoviolation, "bad signature");
33
  }
34
  if (packet.as_slice().truncate(32) != id_.as_slice()) {
35
    return td::Status::Error(ErrorCode::protoviolation, "bad proxy id");
36
  }
37
  Packet p{};
38
  p.flags = 0;
39
  p.ip = 0;
40
  p.port = 0;
41
  p.adnl_start_time = 0;
42
  p.seqno = 0;
43
  p.date = 0;
44
  p.data = std::move(packet);
45
  p.data.confirm_read(32);
46
  return std::move(p);
47
}
48

49
td::BufferSlice AdnlProxyFast::encrypt(Packet packet) const {
50
  if (!packet.date) {
51
    packet.date = static_cast<td::int32>(td::Clocks::system());
52
    packet.flags |= 8;
53
  }
54
  auto obj = create_tl_object<ton_api::adnl_proxyPacketHeader>(id_, packet.flags, packet.ip, packet.port,
55
                                                               packet.adnl_start_time, packet.seqno, packet.date,
56
                                                               td::sha256_bits256(packet.data.as_slice()));
57
  char data[64];
58
  td::MutableSlice S{data, 64};
59
  S.copy_from(get_tl_object_sha256(obj).as_slice());
60
  S.remove_prefix(32);
61
  S.copy_from(shared_secret_.as_slice());
62

63
  obj->signature_ = td::sha256_bits256(td::Slice(data, 64));
64

65
  return serialize_tl_object(obj, false, std::move(packet.data));
66
}
67

68
td::Result<AdnlProxy::Packet> AdnlProxyFast::decrypt(td::BufferSlice packet) const {
69
  TRY_RESULT(obj, fetch_tl_prefix<ton_api::adnl_proxyPacketHeader>(packet, false));
70
  if (obj->proxy_id_ != id_) {
71
    return td::Status::Error(ErrorCode::protoviolation, "bad proxy id");
72
  }
73

74
  auto signature = std::move(obj->signature_);
75
  obj->signature_ = td::sha256_bits256(packet.as_slice());
76

77
  char data[64];
78
  td::MutableSlice S{data, 64};
79
  S.copy_from(get_tl_object_sha256(obj).as_slice());
80
  S.remove_prefix(32);
81
  S.copy_from(shared_secret_.as_slice());
82

83
  if (td::sha256_bits256(td::Slice(data, 64)) != signature) {
84
    return td::Status::Error(ErrorCode::protoviolation, "bad signature");
85
  }
86

87
  Packet p;
88
  p.flags = obj->flags_;
89
  p.ip = (p.flags & 1) ? obj->ip_ : 0;
90
  p.port = (p.flags & 1) ? static_cast<td::uint16>(obj->port_) : 0;
91
  p.adnl_start_time = (p.flags & 2) ? obj->adnl_start_time_ : 0;
92
  p.seqno = (p.flags & 4) ? obj->seqno_ : 0;
93
  p.date = (p.flags & 8) ? obj->date_ : 0;
94
  p.data = std::move(packet);
95

96
  return std::move(p);
97
}
98

99
td::Result<std::shared_ptr<AdnlProxy>> AdnlProxy::create(const ton_api::adnl_Proxy &proxy_type) {
100
  std::shared_ptr<AdnlProxy> R;
101
  ton_api::downcast_call(
102
      const_cast<ton_api::adnl_Proxy &>(proxy_type),
103
      td::overloaded([&](const ton_api::adnl_proxy_none &x) { R = std::make_shared<AdnlProxyNone>(x.id_); },
104
                     [&](const ton_api::adnl_proxy_fast &x) {
105
                       R = std::make_shared<AdnlProxyFast>(x.id_, x.shared_secret_.as_slice());
106
                     }));
107
  return std::move(R);
108
}
109

110
}  // namespace adnl
111

112
}  // namespace ton
113