1
0
Fork 0
mirror of https://github.com/ton-blockchain/ton synced 2025-03-09 15:40:10 +00:00

Merge branch 'testnet' into accelerator

This commit is contained in:
SpyCheese 2024-08-15 15:42:33 +03:00
commit 3950b7eb9a
18 changed files with 238 additions and 116 deletions

View file

@ -269,7 +269,11 @@ void AdnlPeerPairImpl::send_messages_in(std::vector<OutboundAdnlMessage> message
size_t ptr = 0;
bool first = true;
do {
respond_with_nop_after_ = td::Timestamp::in(td::Random::fast(1.0, 2.0));
bool try_reinit = try_reinit_at_ && try_reinit_at_.is_in_past();
if (try_reinit) {
try_reinit_at_ = td::Timestamp::in(td::Random::fast(0.5, 1.5));
}
bool via_channel = channel_ready_ && !try_reinit;
size_t s = (via_channel ? channel_packet_header_max_size() : packet_header_max_size());
if (first) {
@ -504,12 +508,6 @@ void AdnlPeerPairImpl::create_channel(pubkeys::Ed25519 pub, td::uint32 date) {
void AdnlPeerPairImpl::process_message(const adnlmessage::AdnlMessageCreateChannel &message) {
create_channel(message.key(), message.date());
if (respond_to_channel_create_after_.is_in_past()) {
respond_to_channel_create_after_ = td::Timestamp::in(td::Random::fast(1.0, 2.0));
std::vector<OutboundAdnlMessage> messages;
messages.emplace_back(adnlmessage::AdnlMessageNop{}, 0);
send_messages(std::move(messages));
}
}
void AdnlPeerPairImpl::process_message(const adnlmessage::AdnlMessageConfirmChannel &message) {
@ -526,6 +524,7 @@ void AdnlPeerPairImpl::process_message(const adnlmessage::AdnlMessageConfirmChan
}
void AdnlPeerPairImpl::process_message(const adnlmessage::AdnlMessageCustom &message) {
respond_with_nop();
td::actor::send_closure(local_actor_, &AdnlLocalId::deliver, peer_id_short_, message.data());
}
@ -538,6 +537,7 @@ void AdnlPeerPairImpl::process_message(const adnlmessage::AdnlMessageReinit &mes
}
void AdnlPeerPairImpl::process_message(const adnlmessage::AdnlMessageQuery &message) {
respond_with_nop();
auto P = td::PromiseCreator::lambda([SelfId = actor_id(this), query_id = message.query_id(),
flags = static_cast<td::uint32>(0)](td::Result<td::BufferSlice> R) {
if (R.is_error()) {
@ -556,6 +556,7 @@ void AdnlPeerPairImpl::process_message(const adnlmessage::AdnlMessageQuery &mess
}
void AdnlPeerPairImpl::process_message(const adnlmessage::AdnlMessageAnswer &message) {
respond_with_nop();
auto Q = out_queries_.find(message.query_id());
if (Q == out_queries_.end()) {
@ -573,6 +574,7 @@ void AdnlPeerPairImpl::process_message(const adnlmessage::AdnlMessageAnswer &mes
}
void AdnlPeerPairImpl::process_message(const adnlmessage::AdnlMessagePart &message) {
respond_with_nop();
auto size = message.total_size();
if (size > huge_packet_max_size()) {
VLOG(ADNL_WARNING) << this << ": dropping too big huge message: size=" << size;
@ -635,6 +637,14 @@ void AdnlPeerPairImpl::delete_query(AdnlQueryId id) {
}
}
void AdnlPeerPairImpl::respond_with_nop() {
if (respond_with_nop_after_.is_in_past()) {
std::vector<OutboundAdnlMessage> messages;
messages.emplace_back(adnlmessage::AdnlMessageNop{}, 0);
send_messages(std::move(messages));
}
}
void AdnlPeerPairImpl::reinit(td::int32 date) {
if (reinit_date_ == 0) {
reinit_date_ = date;

View file

@ -122,6 +122,7 @@ class AdnlPeerPairImpl : public AdnlPeerPair {
}
private:
void respond_with_nop();
void reinit(td::int32 date);
td::Result<std::pair<td::actor::ActorId<AdnlNetworkConnection>, bool>> get_conn(bool direct_only);
void create_channel(pubkeys::Ed25519 pub, td::uint32 date);
@ -214,7 +215,7 @@ class AdnlPeerPairImpl : public AdnlPeerPair {
pubkeys::Ed25519 channel_pub_;
td::int32 channel_pk_date_;
td::actor::ActorOwn<AdnlChannel> channel_;
td::Timestamp respond_to_channel_create_after_;
td::Timestamp respond_with_nop_after_;
td::uint64 in_seqno_ = 0;
td::uint64 out_seqno_ = 0;

View file

@ -93,12 +93,13 @@ bool aggregate_verify(const std::vector<std::pair<P1, td::BufferSlice>> &pubs_ms
return false;
}
std::unique_ptr<blst::Pairing> pairing = std::make_unique<blst::Pairing>(true, DST);
blst::P2_Affine p2_zero;
for (const auto &p : pubs_msgs) {
blst::P1_Affine p1(p.first.data(), P1_SIZE);
if (!p1.in_group() || p1.is_inf()) {
return false;
}
pairing->aggregate(&p1, nullptr, (const td::uint8 *)p.second.data(), p.second.size());
pairing->aggregate(&p1, &p2_zero, (const td::uint8 *)p.second.data(), p.second.size());
}
pairing->commit();
blst::P2_Affine p2(sig.data(), P2_SIZE);

View file

@ -179,6 +179,7 @@ class DhtMemberImpl : public DhtMember {
void get_value(DhtKey key, td::Promise<DhtValue> result) override {
get_value_in(key.compute_key_id(), std::move(result));
}
void get_value_many(DhtKey key, std::function<void(DhtValue)> callback, td::Promise<td::Unit> promise) override;
void alarm() override {
alarm_timestamp() = td::Timestamp::in(1.0);

View file

@ -210,8 +210,11 @@ void DhtQueryFindValue::on_result(td::Result<td::BufferSlice> R, adnl::AdnlNodeI
send_get_nodes = true;
return;
}
promise_.set_value(std::move(value));
need_stop = true;
if (on_value_found(std::move(value))) {
send_get_nodes = true;
} else {
need_stop = true;
}
},
[&](ton_api::dht_valueNotFound &v) {
add_nodes(DhtNodesList{std::move(v.nodes_), our_network_id()});
@ -244,7 +247,32 @@ void DhtQueryFindValue::on_result_nodes(td::Result<td::BufferSlice> R, adnl::Adn
}
void DhtQueryFindValue::finish(DhtNodesList list) {
promise_.set_error(td::Status::Error(ErrorCode::notready, "dht key not found"));
}
bool DhtQueryFindValueSingle::on_value_found(DhtValue value) {
promise_.set_value(std::move(value));
found_ = true;
return false;
}
void DhtQueryFindValueSingle::tear_down() {
if (!found_) {
promise_.set_error(td::Status::Error(ErrorCode::notready, "dht key not found"));
}
}
bool DhtQueryFindValueMany::on_value_found(DhtValue value) {
callback_(std::move(value));
found_ = true;
return true;
}
void DhtQueryFindValueMany::tear_down() {
if (found_) {
promise_.set_value(td::Unit());
} else {
promise_.set_error(td::Status::Error(ErrorCode::notready, "dht key not found"));
}
}
DhtQueryStore::DhtQueryStore(DhtValue key_value, DhtMember::PrintId print_id, adnl::AdnlNodeIdShort src,

View file

@ -126,16 +126,11 @@ class DhtQueryFindNodes : public DhtQuery {
};
class DhtQueryFindValue : public DhtQuery {
private:
td::Promise<DhtValue> promise_;
public:
DhtQueryFindValue(DhtKeyId key, DhtMember::PrintId print_id, adnl::AdnlNodeIdShort src, DhtNodesList list,
td::uint32 k, td::uint32 a, td::int32 our_network_id, DhtNode self, bool client_only,
td::actor::ActorId<DhtMember> node, td::actor::ActorId<adnl::Adnl> adnl,
td::Promise<DhtValue> promise)
: DhtQuery(key, print_id, src, k, a, our_network_id, std::move(self), client_only, node, adnl)
, promise_(std::move(promise)) {
td::actor::ActorId<DhtMember> node, td::actor::ActorId<adnl::Adnl> adnl)
: DhtQuery(key, print_id, src, k, a, our_network_id, std::move(self), client_only, node, adnl) {
add_nodes(std::move(list));
}
void send_one_query(adnl::AdnlNodeIdShort id) override;
@ -146,6 +141,48 @@ class DhtQueryFindValue : public DhtQuery {
std::string get_name() const override {
return "find value";
}
virtual bool on_value_found(DhtValue value) = 0;
};
class DhtQueryFindValueSingle : public DhtQueryFindValue {
public:
DhtQueryFindValueSingle(DhtKeyId key, DhtMember::PrintId print_id, adnl::AdnlNodeIdShort src, DhtNodesList list,
td::uint32 k, td::uint32 a, td::int32 our_network_id, DhtNode self, bool client_only,
td::actor::ActorId<DhtMember> node, td::actor::ActorId<adnl::Adnl> adnl,
td::Promise<DhtValue> promise)
: DhtQueryFindValue(key, print_id, src, std::move(list), k, a, our_network_id, std::move(self), client_only, node,
adnl)
, promise_(std::move(promise)) {
add_nodes(std::move(list));
}
bool on_value_found(DhtValue value) override;
void tear_down() override;
private:
td::Promise<DhtValue> promise_;
bool found_ = false;
};
class DhtQueryFindValueMany : public DhtQueryFindValue {
public:
DhtQueryFindValueMany(DhtKeyId key, DhtMember::PrintId print_id, adnl::AdnlNodeIdShort src, DhtNodesList list,
td::uint32 k, td::uint32 a, td::int32 our_network_id, DhtNode self, bool client_only,
td::actor::ActorId<DhtMember> node, td::actor::ActorId<adnl::Adnl> adnl,
std::function<void(DhtValue)> callback, td::Promise<td::Unit> promise)
: DhtQueryFindValue(key, print_id, src, std::move(list), k, a, our_network_id, std::move(self), client_only, node,
adnl)
, callback_(std::move(callback))
, promise_(std::move(promise)) {
add_nodes(std::move(list));
}
bool on_value_found(DhtValue value) override;
void tear_down() override;
private:
std::function<void(DhtValue)> callback_;
td::Promise<td::Unit> promise_;
bool found_ = false;
};
class DhtQueryStore : public td::actor::Actor {

View file

@ -470,7 +470,7 @@ void DhtMemberImpl::get_value_in(DhtKeyId key, td::Promise<DhtValue> result) {
network_id = network_id_, id = id_,
client_only = client_only_](td::Result<DhtNode> R) mutable {
R.ensure();
td::actor::create_actor<DhtQueryFindValue>("FindValueQuery", key, print_id, id, std::move(list), k, a, network_id,
td::actor::create_actor<DhtQueryFindValueSingle>("FindValueQuery", key, print_id, id, std::move(list), k, a, network_id,
R.move_as_ok(), client_only, SelfId, adnl, std::move(promise))
.release();
});
@ -478,6 +478,21 @@ void DhtMemberImpl::get_value_in(DhtKeyId key, td::Promise<DhtValue> result) {
get_self_node(std::move(P));
}
void DhtMemberImpl::get_value_many(DhtKey key, std::function<void(DhtValue)> callback, td::Promise<td::Unit> promise) {
DhtKeyId key_id = key.compute_key_id();
auto P = td::PromiseCreator::lambda(
[key = key_id, callback = std::move(callback), promise = std::move(promise), SelfId = actor_id(this),
print_id = print_id(), adnl = adnl_, list = get_nearest_nodes(key_id, k_ * 2), k = k_, a = a_,
network_id = network_id_, id = id_, client_only = client_only_](td::Result<DhtNode> R) mutable {
R.ensure();
td::actor::create_actor<DhtQueryFindValueMany>("FindValueManyQuery", key, print_id, id, std::move(list), k, a,
network_id, R.move_as_ok(), client_only, SelfId, adnl,
std::move(callback), std::move(promise))
.release();
});
get_self_node(std::move(P));
}
void DhtMemberImpl::register_reverse_connection(adnl::AdnlNodeIdFull client, td::Promise<td::Unit> promise) {
auto client_short = client.compute_short_id();
td::uint32 ttl = (td::uint32)td::Clocks::system() + 300;

View file

@ -53,6 +53,7 @@ class Dht : public td::actor::Actor {
virtual void set_value(DhtValue key_value, td::Promise<td::Unit> result) = 0;
virtual void get_value(DhtKey key, td::Promise<DhtValue> result) = 0;
virtual void get_value_many(DhtKey key, std::function<void(DhtValue)> callback, td::Promise<td::Unit> promise) = 0;
virtual void register_reverse_connection(adnl::AdnlNodeIdFull client, td::Promise<td::Unit> promise) = 0;
virtual void request_reverse_ping(adnl::AdnlNode target, adnl::AdnlNodeIdShort client,

View file

@ -27,6 +27,16 @@ namespace ton {
namespace keyring {
KeyringImpl::PrivateKeyDescr::PrivateKeyDescr(PrivateKey private_key, bool is_temp)
: public_key(private_key.compute_public_key()), is_temp(is_temp) {
auto D = private_key.create_decryptor_async();
D.ensure();
decryptor_sign = D.move_as_ok();
D = private_key.create_decryptor_async();
D.ensure();
decryptor_decrypt = D.move_as_ok();
}
void KeyringImpl::start_up() {
if (db_root_.size() > 0) {
td::mkdir(db_root_).ensure();
@ -45,23 +55,19 @@ td::Result<KeyringImpl::PrivateKeyDescr *> KeyringImpl::load_key(PublicKeyHash k
auto name = db_root_ + "/" + key_hash.bits256_value().to_hex();
auto R = td::read_file(td::CSlice{name});
auto R = td::read_file_secure(td::CSlice{name});
if (R.is_error()) {
return R.move_as_error_prefix("key not in db: ");
}
auto data = R.move_as_ok();
auto R2 = PrivateKey::import(td::SecureString(data));
auto R2 = PrivateKey::import(data);
R2.ensure();
auto key = R2.move_as_ok();
auto pub = key.compute_public_key();
auto short_id = pub.compute_short_id();
auto desc = std::make_unique<PrivateKeyDescr>(key, false);
auto short_id = desc->public_key.compute_short_id();
CHECK(short_id == key_hash);
auto D = key.create_decryptor_async();
D.ensure();
return map_.emplace(short_id, std::make_unique<PrivateKeyDescr>(D.move_as_ok(), pub, false)).first->second.get();
return map_.emplace(short_id, std::move(desc)).first->second.get();
}
void KeyringImpl::add_key(PrivateKey key, bool is_temp, td::Promise<td::Unit> promise) {
@ -76,10 +82,7 @@ void KeyringImpl::add_key(PrivateKey key, bool is_temp, td::Promise<td::Unit> pr
if (db_root_.size() == 0) {
CHECK(is_temp);
}
auto D = key.create_decryptor_async();
D.ensure();
map_.emplace(short_id, std::make_unique<PrivateKeyDescr>(D.move_as_ok(), pub, is_temp));
map_.emplace(short_id, std::make_unique<PrivateKeyDescr>(key, is_temp));
if (!is_temp && key.exportable()) {
auto S = key.export_as_slice();
@ -139,7 +142,7 @@ void KeyringImpl::sign_message(PublicKeyHash key_hash, td::BufferSlice data, td:
if (S.is_error()) {
promise.set_error(S.move_as_error());
} else {
td::actor::send_closure(S.move_as_ok()->decryptor, &DecryptorAsync::sign, std::move(data), std::move(promise));
td::actor::send_closure(S.move_as_ok()->decryptor_sign, &DecryptorAsync::sign, std::move(data), std::move(promise));
}
}
@ -161,7 +164,7 @@ void KeyringImpl::sign_add_get_public_key(PublicKeyHash key_hash, td::BufferSlic
}
promise.set_value(std::pair<td::BufferSlice, PublicKey>{R.move_as_ok(), id});
});
td::actor::send_closure(D->decryptor, &DecryptorAsync::sign, std::move(data), std::move(P));
td::actor::send_closure(D->decryptor_sign, &DecryptorAsync::sign, std::move(data), std::move(P));
}
void KeyringImpl::sign_messages(PublicKeyHash key_hash, std::vector<td::BufferSlice> data,
@ -171,7 +174,7 @@ void KeyringImpl::sign_messages(PublicKeyHash key_hash, std::vector<td::BufferSl
if (S.is_error()) {
promise.set_error(S.move_as_error());
} else {
td::actor::send_closure(S.move_as_ok()->decryptor, &DecryptorAsync::sign_batch, std::move(data),
td::actor::send_closure(S.move_as_ok()->decryptor_sign, &DecryptorAsync::sign_batch, std::move(data),
std::move(promise));
}
}
@ -182,7 +185,8 @@ void KeyringImpl::decrypt_message(PublicKeyHash key_hash, td::BufferSlice data,
if (S.is_error()) {
promise.set_error(S.move_as_error());
} else {
td::actor::send_closure(S.move_as_ok()->decryptor, &DecryptorAsync::decrypt, std::move(data), std::move(promise));
td::actor::send_closure(S.move_as_ok()->decryptor_decrypt, &DecryptorAsync::decrypt, std::move(data),
std::move(promise));
}
}

View file

@ -30,12 +30,11 @@ namespace keyring {
class KeyringImpl : public Keyring {
private:
struct PrivateKeyDescr {
td::actor::ActorOwn<DecryptorAsync> decryptor;
td::actor::ActorOwn<DecryptorAsync> decryptor_sign;
td::actor::ActorOwn<DecryptorAsync> decryptor_decrypt;
PublicKey public_key;
bool is_temp;
PrivateKeyDescr(td::actor::ActorOwn<DecryptorAsync> decryptor, PublicKey public_key, bool is_temp)
: decryptor(std::move(decryptor)), public_key(public_key), is_temp(is_temp) {
}
PrivateKeyDescr(PrivateKey private_key, bool is_temp);
};
public:

View file

@ -29,28 +29,6 @@
namespace ton {
td::Result<std::unique_ptr<Encryptor>> Encryptor::create(const ton_api::PublicKey *id) {
td::Result<std::unique_ptr<Encryptor>> res;
ton_api::downcast_call(
*const_cast<ton_api::PublicKey *>(id),
td::overloaded([&](const ton_api::pub_unenc &obj) { res = std::make_unique<EncryptorNone>(); },
[&](const ton_api::pub_ed25519 &obj) { res = std::make_unique<EncryptorEd25519>(obj.key_); },
[&](const ton_api::pub_overlay &obj) { res = std::make_unique<EncryptorOverlay>(); },
[&](const ton_api::pub_aes &obj) { res = std::make_unique<EncryptorAES>(obj.key_); }));
return res;
}
td::Result<std::unique_ptr<Decryptor>> Decryptor::create(const ton_api::PrivateKey *id) {
td::Result<std::unique_ptr<Decryptor>> res;
ton_api::downcast_call(
*const_cast<ton_api::PrivateKey *>(id),
td::overloaded([&](const ton_api::pk_unenc &obj) { res = std::make_unique<DecryptorNone>(); },
[&](const ton_api::pk_ed25519 &obj) { res = std::make_unique<DecryptorEd25519>(obj.key_); },
[&](const ton_api::pk_overlay &obj) { res = std::make_unique<DecryptorFail>(); },
[&](const ton_api::pk_aes &obj) { res = std::make_unique<DecryptorAES>(obj.key_); }));
return res;
}
td::Result<td::BufferSlice> EncryptorEd25519::encrypt(td::Slice data) {
TRY_RESULT_PREFIX(pk, td::Ed25519::generate_private_key(), "failed to generate private key: ");
TRY_RESULT_PREFIX(pubkey, pk.get_public_key(), "failed to get public key from private: ");

View file

@ -31,7 +31,6 @@ class Encryptor {
virtual td::Result<td::BufferSlice> encrypt(td::Slice data) = 0;
virtual td::Status check_signature(td::Slice message, td::Slice signature) = 0;
virtual ~Encryptor() = default;
static td::Result<std::unique_ptr<Encryptor>> create(const ton_api::PublicKey *id);
};
class Decryptor {
@ -40,7 +39,6 @@ class Decryptor {
virtual td::Result<td::BufferSlice> sign(td::Slice data) = 0;
virtual std::vector<td::Result<td::BufferSlice>> sign_batch(std::vector<td::Slice> data);
virtual ~Decryptor() = default;
static td::Result<std::unique_ptr<Decryptor>> create(const ton_api::PrivateKey *id);
};
class EncryptorAsync : public td::actor::Actor {
@ -61,16 +59,6 @@ class EncryptorAsync : public td::actor::Actor {
void encrypt(td::BufferSlice data, td::Promise<td::BufferSlice> promise) {
promise.set_result(encryptor_->encrypt(data.as_slice()));
}
template <class T>
static td::Result<td::actor::ActorOwn<EncryptorAsync>> create(T &id) {
TRY_RESULT(d, Encryptor::create(id));
return td::actor::create_actor<EncryptorAsync>("encryptor", std::move(d));
}
template <class T>
static td::Result<td::actor::ActorOwn<EncryptorAsync>> create(T *id) {
TRY_RESULT(d, Encryptor::create(id));
return td::actor::create_actor<EncryptorAsync>("encryptor", std::move(d));
}
};
class DecryptorAsync : public td::actor::Actor {
@ -94,16 +82,6 @@ class DecryptorAsync : public td::actor::Actor {
}
return decryptor_->sign_batch(v);
}
template <class T>
static td::Result<td::actor::ActorOwn<DecryptorAsync>> create(T &id) {
TRY_RESULT(d, Decryptor::create(id));
return td::actor::create_actor<DecryptorAsync>("decryptor", std::move(d));
}
template <class T>
static td::Result<td::actor::ActorOwn<DecryptorAsync>> create(T *id) {
TRY_RESULT(d, Decryptor::create(id));
return td::actor::create_actor<DecryptorAsync>("decryptor", std::move(d));
}
};
} // namespace ton

View file

@ -83,7 +83,7 @@ class EncryptorEd25519 : public Encryptor {
td::Result<td::BufferSlice> encrypt(td::Slice data) override;
td::Status check_signature(td::Slice message, td::Slice signature) override;
EncryptorEd25519(td::Bits256 key) : pub_(td::SecureString(as_slice(key))) {
EncryptorEd25519(const td::Bits256& key) : pub_(td::SecureString(as_slice(key))) {
}
};
@ -94,7 +94,7 @@ class DecryptorEd25519 : public Decryptor {
public:
td::Result<td::BufferSlice> decrypt(td::Slice data) override;
td::Result<td::BufferSlice> sign(td::Slice data) override;
DecryptorEd25519(td::Bits256 key) : pk_(td::SecureString(as_slice(key))) {
DecryptorEd25519(const td::Bits256& key) : pk_(td::SecureString(as_slice(key))) {
}
};
@ -129,12 +129,15 @@ class EncryptorAES : public Encryptor {
td::Bits256 shared_secret_;
public:
~EncryptorAES() override {
shared_secret_.set_zero_s();
}
td::Result<td::BufferSlice> encrypt(td::Slice data) override;
td::Status check_signature(td::Slice message, td::Slice signature) override {
return td::Status::Error("can no sign channel messages");
}
EncryptorAES(td::Bits256 shared_secret) : shared_secret_(shared_secret) {
EncryptorAES(const td::Bits256& shared_secret) : shared_secret_(shared_secret) {
}
};
@ -143,11 +146,14 @@ class DecryptorAES : public Decryptor {
td::Bits256 shared_secret_;
public:
~DecryptorAES() override {
shared_secret_.set_zero_s();
}
td::Result<td::BufferSlice> decrypt(td::Slice data) override;
td::Result<td::BufferSlice> sign(td::Slice data) override {
return td::Status::Error("can no sign channel messages");
}
DecryptorAES(td::Bits256 shared_secret) : shared_secret_(shared_secret) {
DecryptorAES(const td::Bits256& shared_secret) : shared_secret_(shared_secret) {
}
};

View file

@ -21,6 +21,7 @@
#include "td/utils/overloaded.h"
#include "tl-utils/tl-utils.hpp"
#include "encryptor.h"
#include "encryptor.hpp"
#include "crypto/Ed25519.h"
namespace ton {
@ -63,12 +64,31 @@ td::Result<PublicKey> PublicKey::import(td::Slice s) {
return PublicKey{x};
}
td::Result<std::unique_ptr<Encryptor>> pubkeys::Ed25519::create_encryptor() const {
return std::make_unique<EncryptorEd25519>(data_);
}
td::Result<std::unique_ptr<Encryptor>> pubkeys::AES::create_encryptor() const {
return std::make_unique<EncryptorAES>(data_);
}
td::Result<std::unique_ptr<Encryptor>> pubkeys::Unenc::create_encryptor() const {
return std::make_unique<EncryptorNone>();
}
td::Result<std::unique_ptr<Encryptor>> pubkeys::Overlay::create_encryptor() const {
return std::make_unique<EncryptorOverlay>();
}
td::Result<std::unique_ptr<Encryptor>> PublicKey::create_encryptor() const {
return Encryptor::create(tl().get());
td::Result<std::unique_ptr<Encryptor>> res;
pub_key_.visit([&](auto &obj) { res = obj.create_encryptor(); });
return res;
}
td::Result<td::actor::ActorOwn<EncryptorAsync>> PublicKey::create_encryptor_async() const {
return EncryptorAsync::create(tl().get());
TRY_RESULT(encryptor, create_encryptor());
return td::actor::create_actor<EncryptorAsync>("encryptor", std::move(encryptor));
}
bool PublicKey::empty() const {
@ -109,6 +129,22 @@ privkeys::Ed25519::Ed25519(td::Ed25519::PrivateKey key) {
data_.as_slice().copy_from(td::Slice(s));
}
td::Result<std::unique_ptr<Decryptor>> privkeys::Ed25519::create_decryptor() const {
return std::make_unique<DecryptorEd25519>(data_);
}
td::Result<std::unique_ptr<Decryptor>> privkeys::AES::create_decryptor() const {
return std::make_unique<DecryptorAES>(data_);
}
td::Result<std::unique_ptr<Decryptor>> privkeys::Unenc::create_decryptor() const {
return std::make_unique<DecryptorNone>();
}
td::Result<std::unique_ptr<Decryptor>> privkeys::Overlay::create_decryptor() const {
return std::make_unique<DecryptorFail>();
}
pubkeys::Ed25519::Ed25519(td::Ed25519::PublicKey key) {
auto s = key.as_octet_string();
CHECK(s.length() == 32);
@ -188,11 +224,14 @@ tl_object_ptr<ton_api::PrivateKey> PrivateKey::tl() const {
}
td::Result<std::unique_ptr<Decryptor>> PrivateKey::create_decryptor() const {
return Decryptor::create(tl().get());
td::Result<std::unique_ptr<Decryptor>> res;
priv_key_.visit([&](auto &obj) { res = obj.create_decryptor(); });
return res;
}
td::Result<td::actor::ActorOwn<DecryptorAsync>> PrivateKey::create_decryptor_async() const {
return DecryptorAsync::create(tl().get());
TRY_RESULT(decryptor, create_decryptor());
return td::actor::create_actor<DecryptorAsync>("decryptor", std::move(decryptor));
}
} // namespace ton

View file

@ -110,6 +110,7 @@ class Ed25519 {
tl_object_ptr<ton_api::pub_ed25519> tl() const {
return create_tl_object<ton_api::pub_ed25519>(data_);
}
td::Result<std::unique_ptr<Encryptor>> create_encryptor() const;
bool operator==(const Ed25519 &with) const {
return data_ == with.data_;
}
@ -141,6 +142,7 @@ class AES {
tl_object_ptr<ton_api::pub_aes> tl() const {
return create_tl_object<ton_api::pub_aes>(data_);
}
td::Result<std::unique_ptr<Encryptor>> create_encryptor() const;
bool operator==(const AES &with) const {
return data_ == with.data_;
}
@ -172,6 +174,7 @@ class Unenc {
tl_object_ptr<ton_api::pub_unenc> tl() const {
return create_tl_object<ton_api::pub_unenc>(data_.clone_as_buffer_slice());
}
td::Result<std::unique_ptr<Encryptor>> create_encryptor() const;
bool operator==(const Unenc &with) const {
return data_.as_slice() == with.data_.as_slice();
}
@ -203,6 +206,7 @@ class Overlay {
tl_object_ptr<ton_api::pub_overlay> tl() const {
return create_tl_object<ton_api::pub_overlay>(data_.clone_as_buffer_slice());
}
td::Result<std::unique_ptr<Encryptor>> create_encryptor() const;
bool operator==(const Overlay &with) const {
return data_.as_slice() == with.data_.as_slice();
}
@ -223,6 +227,9 @@ class PublicKey {
td::uint32 serialized_size() const {
UNREACHABLE();
}
td::Result<std::unique_ptr<Encryptor>> create_encryptor() const {
UNREACHABLE();
}
bool operator==(const Empty &with) const {
return false;
}
@ -320,6 +327,7 @@ class Ed25519 {
}
tl_object_ptr<ton_api::PublicKey> pub_tl() const;
pubkeys::Ed25519 pub() const;
td::Result<std::unique_ptr<Decryptor>> create_decryptor() const;
static Ed25519 random();
};
@ -363,6 +371,7 @@ class AES {
pubkeys::AES pub() const {
return pubkeys::AES{data_};
}
td::Result<std::unique_ptr<Decryptor>> create_decryptor() const;
};
class Unenc {
@ -397,6 +406,7 @@ class Unenc {
pubkeys::Unenc pub() const {
return pubkeys::Unenc{data_.clone()};
}
td::Result<std::unique_ptr<Decryptor>> create_decryptor() const;
};
class Overlay {
@ -431,6 +441,7 @@ class Overlay {
pubkeys::Overlay pub() const {
return pubkeys::Overlay{data_.clone()};
}
td::Result<std::unique_ptr<Decryptor>> create_decryptor() const;
};
} // namespace privkeys
@ -454,6 +465,9 @@ class PrivateKey {
PublicKey pub() const {
UNREACHABLE();
}
td::Result<std::unique_ptr<Decryptor>> create_decryptor() const {
UNREACHABLE();
}
};
td::Variant<Empty, privkeys::Ed25519, privkeys::AES, privkeys::Unenc, privkeys::Overlay> priv_key_{Empty{}};

View file

@ -321,11 +321,14 @@ void OverlayImpl::alarm() {
}
if (next_dht_query_ && next_dht_query_.is_in_past() && overlay_type_ == OverlayType::Public) {
next_dht_query_ = td::Timestamp::never();
auto P = td::PromiseCreator::lambda([SelfId = actor_id(this)](td::Result<dht::DhtValue> res) {
td::actor::send_closure(SelfId, &OverlayImpl::receive_dht_nodes, std::move(res), true);
});
td::actor::send_closure(dht_node_, &dht::Dht::get_value, dht::DhtKey{overlay_id_.pubkey_hash(), "nodes", 0},
std::move(P));
std::function<void(dht::DhtValue)> callback = [SelfId = actor_id(this)](dht::DhtValue value) {
td::actor::send_closure(SelfId, &OverlayImpl::receive_dht_nodes, std::move(value));
};
td::Promise<td::Unit> on_finish = [SelfId = actor_id(this)](td::Result<td::Unit> R) {
td::actor::send_closure(SelfId, &OverlayImpl::dht_lookup_finished, R.move_as_status());
};
td::actor::send_closure(dht_node_, &dht::Dht::get_value_many, dht::DhtKey{overlay_id_.pubkey_hash(), "nodes", 0},
std::move(callback), std::move(on_finish));
}
if (update_db_at_.is_in_past() && overlay_type_ == OverlayType::Public) {
std::vector<OverlayNode> vec;
@ -350,30 +353,30 @@ void OverlayImpl::alarm() {
}
}
void OverlayImpl::receive_dht_nodes(td::Result<dht::DhtValue> res, bool dummy) {
void OverlayImpl::receive_dht_nodes(dht::DhtValue v) {
CHECK(overlay_type_ == OverlayType::Public);
if (res.is_ok()) {
auto v = res.move_as_ok();
auto R = fetch_tl_object<ton_api::overlay_nodes>(v.value().clone(), true);
if (R.is_ok()) {
auto r = R.move_as_ok();
VLOG(OVERLAY_INFO) << this << ": received " << r->nodes_.size() << " nodes from overlay";
VLOG(OVERLAY_EXTRA_DEBUG) << this << ": nodes: " << ton_api::to_string(r);
std::vector<OverlayNode> nodes;
for (auto &n : r->nodes_) {
auto N = OverlayNode::create(n);
if (N.is_ok()) {
nodes.emplace_back(N.move_as_ok());
}
auto R = fetch_tl_object<ton_api::overlay_nodes>(v.value().clone(), true);
if (R.is_ok()) {
auto r = R.move_as_ok();
VLOG(OVERLAY_INFO) << this << ": received " << r->nodes_.size() << " nodes from overlay";
VLOG(OVERLAY_EXTRA_DEBUG) << this << ": nodes: " << ton_api::to_string(r);
std::vector<OverlayNode> nodes;
for (auto &n : r->nodes_) {
auto N = OverlayNode::create(n);
if (N.is_ok()) {
nodes.emplace_back(N.move_as_ok());
}
add_peers(std::move(nodes));
} else {
VLOG(OVERLAY_WARNING) << this << ": incorrect value in DHT for overlay nodes: " << R.move_as_error();
}
add_peers(std::move(nodes));
} else {
VLOG(OVERLAY_NOTICE) << this << ": can not get value from DHT: " << res.move_as_error();
VLOG(OVERLAY_WARNING) << this << ": incorrect value in DHT for overlay nodes: " << R.move_as_error();
}
}
void OverlayImpl::dht_lookup_finished(td::Status S) {
if (S.is_error()) {
VLOG(OVERLAY_NOTICE) << this << ": can not get value from DHT: " << S;
}
if (!(next_dht_store_query_ && next_dht_store_query_.is_in_past())) {
finish_dht_query();
return;

View file

@ -206,7 +206,8 @@ class OverlayImpl : public Overlay {
}
void update_member_certificate(OverlayMemberCertificate cert) override;
void receive_dht_nodes(td::Result<dht::DhtValue> res, bool dummy);
void receive_dht_nodes(dht::DhtValue v);
void dht_lookup_finished(td::Status S);
void update_dht_nodes(OverlayNode node);
void update_neighbours(td::uint32 nodes_to_change);

View file

@ -555,6 +555,12 @@ class Result {
};
return status_.move_as_error_suffix(suffix);
}
Status move_as_status() TD_WARN_UNUSED_RESULT {
if (status_.is_error()) {
return move_as_error();
}
return Status::OK();
}
const T &ok() const {
LOG_CHECK(status_.is_ok()) << status_;
return value_;