tdlight-team/tdlight
tdlight-team/tdlight
1
1
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Unify names of PacketInfo variables.

Browse Source
This commit is contained in:
levlam 2023-09-10 00:04:55 +03:00
parent 4da0f76d2a
commit efba70c2ef
7 changed files with 137 additions and 132 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

68
td/mtproto/RawConnection.cpp
View File

@ -61,23 +61,23 @@ class RawConnectionDefault final : public RawConnection {
size_t send_crypto(const Storer &storer, uint64 session_id, int64 salt, const AuthKey &auth_key,
uint64 quick_ack_token) final {
PacketInfo info;
info.version = 2;
info.no_crypto_flag = false;
info.salt = salt;
info.session_id = session_id;
info.use_random_padding = transport_->use_random_padding();
PacketInfo packet_info;
packet_info.version = 2;
packet_info.no_crypto_flag = false;
packet_info.salt = salt;
packet_info.session_id = session_id;
packet_info.use_random_padding = transport_->use_random_padding();
auto packet =
Transport::write(storer, auth_key, &info, transport_->max_prepend_size(), transport_->max_append_size());
Transport::write(storer, auth_key, &packet_info, transport_->max_prepend_size(), transport_->max_append_size());
bool use_quick_ack = false;
if (quick_ack_token != 0 && transport_->support_quick_ack()) {
CHECK(info.message_ack & (1u << 31));
auto tmp = quick_ack_to_token_.emplace(info.message_ack, quick_ack_token);
CHECK(packet_info.message_ack & (1u << 31));
auto tmp = quick_ack_to_token_.emplace(packet_info.message_ack, quick_ack_token);
if (tmp.second) {
use_quick_ack = true;
} else {
LOG(ERROR) << "Quick ack " << info.message_ack << " collision";
LOG(ERROR) << "Quick ack " << packet_info.message_ack << " collision";
}
}
@ -87,14 +87,14 @@ class RawConnectionDefault final : public RawConnection {
}
uint64 send_no_crypto(const Storer &storer) final {
PacketInfo info;
info.no_crypto_flag = true;
auto packet =
Transport::write(storer, AuthKey(), &info, transport_->max_prepend_size(), transport_->max_append_size());
PacketInfo packet_info;
packet_info.no_crypto_flag = true;
auto packet = Transport::write(storer, AuthKey(), &packet_info, transport_->max_prepend_size(),
transport_->max_append_size());
LOG(INFO) << "Send handshake packet: " << format::as_hex_dump<4>(packet.as_slice());
transport_->write(std::move(packet), false);
return info.message_id;
return packet_info.message_id;
}
PollableFdInfo &get_poll_info() final {
@ -187,10 +187,10 @@ class RawConnectionDefault final : public RawConnection {
<< old_pointer << ' ' << packet.as_slice().ubegin() << ' ' << BufferSlice(0).as_slice().ubegin() << ' '
<< packet.size() << ' ' << wait_size << ' ' << quick_ack;
PacketInfo info;
info.version = 2;
PacketInfo packet_info;
packet_info.version = 2;
TRY_RESULT(read_result, Transport::read(packet.as_mutable_slice(), auth_key, &info));
TRY_RESULT(read_result, Transport::read(packet.as_mutable_slice(), auth_key, &packet_info));
switch (read_result.type()) {
case Transport::ReadResult::Quickack:
TRY_STATUS(on_quick_ack(read_result.quick_ack(), callback));
@ -206,7 +206,7 @@ class RawConnectionDefault final : public RawConnection {
}
}
TRY_STATUS(callback.on_raw_packet(info, packet.from_slice(read_result.packet())));
TRY_STATUS(callback.on_raw_packet(packet_info, packet.from_slice(read_result.packet())));
break;
case Transport::ReadResult::Nop:
break;
@ -302,13 +302,13 @@ class RawConnectionHttp final : public RawConnection {
size_t send_crypto(const Storer &storer, uint64 session_id, int64 salt, const AuthKey &auth_key,
uint64 quick_ack_token) final {
PacketInfo info;
info.version = 2;
info.no_crypto_flag = false;
info.salt = salt;
info.session_id = session_id;
info.use_random_padding = false;
auto packet = Transport::write(storer, auth_key, &info);
PacketInfo packet_info;
packet_info.version = 2;
packet_info.no_crypto_flag = false;
packet_info.salt = salt;
packet_info.session_id = session_id;
packet_info.use_random_padding = false;
auto packet = Transport::write(storer, auth_key, &packet_info);
auto packet_size = packet.size();
send_packet(packet.as_buffer_slice());
@ -316,13 +316,13 @@ class RawConnectionHttp final : public RawConnection {
}
uint64 send_no_crypto(const Storer &storer) final {
PacketInfo info;
info.no_crypto_flag = true;
auto packet = Transport::write(storer, AuthKey(), &info);
PacketInfo packet_info;
packet_info.no_crypto_flag = true;
auto packet = Transport::write(storer, AuthKey(), &packet_info);
LOG(INFO) << "Send handshake packet: " << format::as_hex_dump<4>(packet.as_slice());
send_packet(packet.as_buffer_slice());
return info.message_id;
return packet_info.message_id;
}
PollableFdInfo &get_poll_info() final {
@ -403,10 +403,10 @@ class RawConnectionHttp final : public RawConnection {
CHECK(mode_ == Receive);
mode_ = Send;
PacketInfo info;
info.version = 2;
PacketInfo packet_info;
packet_info.version = 2;
TRY_RESULT(read_result, Transport::read(packet.as_mutable_slice(), auth_key, &info));
TRY_RESULT(read_result, Transport::read(packet.as_mutable_slice(), auth_key, &packet_info));
switch (read_result.type()) {
case Transport::ReadResult::Quickack: {
break;
@ -423,7 +423,7 @@ class RawConnectionHttp final : public RawConnection {
}
}
TRY_STATUS(callback.on_raw_packet(info, packet.from_slice(read_result.packet())));
TRY_STATUS(callback.on_raw_packet(packet_info, packet.from_slice(read_result.packet())));
break;
}
case Transport::ReadResult::Nop:

2
td/mtproto/RawConnection.h
View File

@ -61,7 +61,7 @@ class RawConnection {
Callback(const Callback &) = delete;
Callback &operator=(const Callback &) = delete;
virtual ~Callback() = default;
virtual Status on_raw_packet(const PacketInfo &info, BufferSlice packet) = 0;
virtual Status on_raw_packet(const PacketInfo &packet_info, BufferSlice packet) = 0;
virtual Status on_quick_ack(uint64 quick_ack_token) {
return Status::Error("Quick acknowledgements are unsupported by the callback");
}

34
td/mtproto/SessionConnection.cpp
View File

@ -544,7 +544,7 @@ Status SessionConnection::parse_packet(TlParser &parser) {
return on_slice_packet(info, packet);
}
Status SessionConnection::on_main_packet(const PacketInfo &info, Slice packet) {
Status SessionConnection::on_main_packet(const PacketInfo &packet_info, Slice packet) {
// Update pong here too. Real pong can be delayed by many big packets
last_pong_at_ = Time::now_cached();
real_last_pong_at_ = last_pong_at_;
@ -555,10 +555,10 @@ Status SessionConnection::on_main_packet(const PacketInfo &info, Slice packet) {
}
VLOG(raw_mtproto) << "Receive packet of size " << packet.size() << ':' << format::as_hex_dump<4>(packet);
VLOG(mtproto) << "Receive packet with seq_no " << info.seq_no << " and msg_id " << format::as_hex(info.message_id)
<< " of size " << packet.size();
VLOG(mtproto) << "Receive packet with seq_no " << packet_info.seq_no << " and msg_id "
<< format::as_hex(packet_info.message_id) << " of size " << packet.size();
if (info.no_crypto_flag) {
if (packet_info.no_crypto_flag) {
return Status::Error("Unencrypted packet");
}
@ -684,27 +684,27 @@ Status SessionConnection::before_write() {
return Status::OK();
}
Status SessionConnection::on_raw_packet(const PacketInfo &info, BufferSlice packet) {
Status SessionConnection::on_raw_packet(const PacketInfo &packet_info, BufferSlice packet) {
auto old_main_message_id = main_message_id_;
main_message_id_ = info.message_id;
main_message_id_ = packet_info.message_id;
SCOPE_EXIT {
main_message_id_ = old_main_message_id;
};
if (info.no_crypto_flag) {
if (packet_info.no_crypto_flag) {
return Status::Error("Unexpected unencrypted packet");
}
bool time_difference_was_updated = false;
auto status =
auth_data_->check_packet(info.session_id, info.message_id, Time::now_cached(), time_difference_was_updated);
auto status = auth_data_->check_packet(packet_info.session_id, packet_info.message_id, Time::now_cached(),
time_difference_was_updated);
if (time_difference_was_updated) {
callback_->on_server_time_difference_updated(false);
}
if (status.is_error()) {
if (status.code() == 1) {
LOG(INFO) << "Packet is ignored: " << status;
send_ack(info.message_id);
send_ack(packet_info.message_id);
return Status::OK();
} else if (status.code() == 2) {
LOG(WARNING) << "Receive too old packet: " << status;
@ -716,7 +716,7 @@ Status SessionConnection::on_raw_packet(const PacketInfo &info, BufferSlice pack
}
auto guard = set_buffer_slice(&packet);
TRY_STATUS(on_main_packet(info, packet.as_slice()));
TRY_STATUS(on_main_packet(packet_info, packet.as_slice()));
return Status::OK();
}
@ -844,12 +844,12 @@ std::pair<uint64, BufferSlice> SessionConnection::encrypted_bind(int64 perm_key,
PacketStorer<QueryImpl> query_storer(query, Slice());
const AuthKey &main_auth_key = auth_data_->get_main_auth_key();
PacketInfo info;
info.version = 1;
info.no_crypto_flag = false;
info.salt = Random::secure_int64();
info.session_id = Random::secure_int64();
auto packet = Transport::write(query_storer, main_auth_key, &info);
PacketInfo packet_info;
packet_info.version = 1;
packet_info.no_crypto_flag = false;
packet_info.salt = Random::secure_int64();
packet_info.session_id = Random::secure_int64();
auto packet = Transport::write(query_storer, main_auth_key, &packet_info);
return std::make_pair(query.message_id, packet.as_buffer_slice());
}

4
td/mtproto/SessionConnection.h
View File

@ -256,7 +256,7 @@ class SessionConnection final
Status on_destroy_auth_key(const mtproto_api::DestroyAuthKeyRes &destroy_auth_key);
Status on_slice_packet(const MsgInfo &info, Slice packet) TD_WARN_UNUSED_RESULT;
Status on_main_packet(const PacketInfo &info, Slice packet) TD_WARN_UNUSED_RESULT;
Status on_main_packet(const PacketInfo &packet_info, Slice packet) TD_WARN_UNUSED_RESULT;
void on_message_failed(uint64 id, Status status);
void on_message_failed_inner(uint64 id);
@ -274,7 +274,7 @@ class SessionConnection final
Status do_flush() TD_WARN_UNUSED_RESULT;
Status before_write() final TD_WARN_UNUSED_RESULT;
Status on_raw_packet(const PacketInfo &info, BufferSlice packet) final;
Status on_raw_packet(const PacketInfo &packet_info, BufferSlice packet) final;
Status on_quick_ack(uint64 quick_ack_token) final;
void on_read(size_t size) final;
};

110
td/mtproto/Transport.cpp
View File

@ -186,10 +186,10 @@ size_t do_calc_crypto_size2_rand(size_t data_size, size_t enc_size, size_t raw_s
} // namespace
template <class HeaderT>
size_t Transport::calc_crypto_size2(size_t data_size, PacketInfo *info) {
size_t Transport::calc_crypto_size2(size_t data_size, PacketInfo *packet_info) {
size_t enc_size = HeaderT::encrypted_header_size();
size_t raw_size = sizeof(HeaderT) - enc_size;
if (info->use_random_padding) {
if (packet_info->use_random_padding) {
return do_calc_crypto_size2_rand(data_size, enc_size, raw_size);
} else {
return do_calc_crypto_size2_basic(data_size, enc_size, raw_size);
@ -200,7 +200,7 @@ size_t Transport::calc_no_crypto_size(size_t data_size) {
return sizeof(NoCryptoHeader) + data_size;
}
Status Transport::read_no_crypto(MutableSlice message, PacketInfo *info, MutableSlice *data) {
Status Transport::read_no_crypto(MutableSlice message, PacketInfo *packet_info, MutableSlice *data) {
if (message.size() < sizeof(NoCryptoHeader)) {
return Status::Error(PSLICE() << "Invalid MTProto message: too small [message.size() = " << message.size()
<< "] < [sizeof(NoCryptoHeader) = " << sizeof(NoCryptoHeader) << "]");
@ -213,7 +213,7 @@ Status Transport::read_no_crypto(MutableSlice message, PacketInfo *info, Mutable
template <class HeaderT, class PrefixT>
Status Transport::read_crypto_impl(int X, MutableSlice message, const AuthKey &auth_key, HeaderT **header_ptr,
PrefixT **prefix_ptr, MutableSlice *data, PacketInfo *info) {
PrefixT **prefix_ptr, MutableSlice *data, PacketInfo *packet_info) {
if (message.size() < sizeof(HeaderT)) {
return Status::Error(PSLICE() << "Invalid MTProto message: too small [message.size() = " << message.size()
<< "] < [sizeof(HeaderT) = " << sizeof(HeaderT) << "]");
@ -232,7 +232,7 @@ Status Transport::read_crypto_impl(int X, MutableSlice message, const AuthKey &a
UInt256 aes_key;
UInt256 aes_iv;
if (info->version == 1) {
if (packet_info->version == 1) {
KDF(auth_key.key(), header->message_key, X, &aes_key, &aes_iv);
} else {
KDF2(auth_key.key(), header->message_key, X, &aes_key, &aes_iv);
@ -251,14 +251,14 @@ Status Transport::read_crypto_impl(int X, MutableSlice message, const AuthKey &a
bool is_length_bad = false;
UInt128 real_message_key;
if (info->version == 1) {
is_length_bad |= info->check_mod4 && prefix->message_data_length % 4 != 0;
if (packet_info->version == 1) {
is_length_bad |= packet_info->check_mod4 && prefix->message_data_length % 4 != 0;
auto expected_size = calc_crypto_size<HeaderT>(data_size);
is_length_bad |= expected_size != message.size();
auto check_size = data_size * (1 - is_length_bad) + tail_size * is_length_bad;
std::tie(info->message_ack, real_message_key) = calc_message_ack_and_key(*header, check_size);
std::tie(packet_info->message_ack, real_message_key) = calc_message_ack_and_key(*header, check_size);
} else {
std::tie(info->message_ack, real_message_key) = calc_message_key2(auth_key, X, to_decrypt);
std::tie(packet_info->message_ack, real_message_key) = calc_message_key2(auth_key, X, to_decrypt);
}
int is_key_bad = false;
@ -271,8 +271,8 @@ Status Transport::read_crypto_impl(int X, MutableSlice message, const AuthKey &a
<< "] [expected = " << format::as_hex_dump(real_message_key) << "]");
}
if (info->version == 2) {
if (info->check_mod4 && prefix->message_data_length % 4 != 0) {
if (packet_info->version == 2) {
if (packet_info->check_mod4 && prefix->message_data_length % 4 != 0) {
return Status::Error(PSLICE() << "Invalid MTProto message: invalid length (not divisible by four)"
<< tag("total_size", message.size())
<< tag("message_data_length", prefix->message_data_length));
@ -299,33 +299,35 @@ Status Transport::read_crypto_impl(int X, MutableSlice message, const AuthKey &a
return Status::OK();
}
Status Transport::read_crypto(MutableSlice message, const AuthKey &auth_key, PacketInfo *info, MutableSlice *data) {
Status Transport::read_crypto(MutableSlice message, const AuthKey &auth_key, PacketInfo *packet_info,
MutableSlice *data) {
CryptoHeader *header = nullptr;
CryptoPrefix *prefix = nullptr;
TRY_STATUS(read_crypto_impl(8, message, auth_key, &header, &prefix, data, info));
TRY_STATUS(read_crypto_impl(8, message, auth_key, &header, &prefix, data, packet_info));
CHECK(header != nullptr);
CHECK(prefix != nullptr);
CHECK(info != nullptr);
info->type = PacketInfo::Common;
info->salt = header->salt;
info->session_id = header->session_id;
info->message_id = prefix->message_id;
info->seq_no = prefix->seq_no;
CHECK(packet_info != nullptr);
packet_info->type = PacketInfo::Common;
packet_info->salt = header->salt;
packet_info->session_id = header->session_id;
packet_info->message_id = prefix->message_id;
packet_info->seq_no = prefix->seq_no;
return Status::OK();
}
Status Transport::read_e2e_crypto(MutableSlice message, const AuthKey &auth_key, PacketInfo *info, MutableSlice *data) {
Status Transport::read_e2e_crypto(MutableSlice message, const AuthKey &auth_key, PacketInfo *packet_info,
MutableSlice *data) {
EndToEndHeader *header = nullptr;
EndToEndPrefix *prefix = nullptr;
TRY_STATUS(read_crypto_impl(info->is_creator && info->version != 1 ? 8 : 0, message, auth_key, &header, &prefix, data,
info));
TRY_STATUS(read_crypto_impl(packet_info->is_creator && packet_info->version != 1 ? 8 : 0, message, auth_key, &header,
&prefix, data, packet_info));
CHECK(header != nullptr);
CHECK(prefix != nullptr);
CHECK(info != nullptr);
info->type = PacketInfo::EndToEnd;
CHECK(packet_info != nullptr);
packet_info->type = PacketInfo::EndToEnd;
return Status::OK();
}
BufferWriter Transport::write_no_crypto(const Storer &storer, PacketInfo *info, size_t prepend_size,
BufferWriter Transport::write_no_crypto(const Storer &storer, PacketInfo *packet_info, size_t prepend_size,
size_t append_size) {
size_t size = calc_no_crypto_size(storer.size());
auto packet = BufferWriter{size, prepend_size, append_size};
@ -339,7 +341,7 @@ BufferWriter Transport::write_no_crypto(const Storer &storer, PacketInfo *info,
}
template <class HeaderT>
void Transport::write_crypto_impl(int X, const Storer &storer, const AuthKey &auth_key, PacketInfo *info,
void Transport::write_crypto_impl(int X, const Storer &storer, const AuthKey &auth_key, PacketInfo *packet_info,
HeaderT *header, size_t data_size, size_t padded_size) {
auto real_data_size = storer.store(header->data);
CHECK(real_data_size == data_size);
@ -352,47 +354,47 @@ void Transport::write_crypto_impl(int X, const Storer &storer, const AuthKey &au
UInt256 aes_key;
UInt256 aes_iv;
if (info->version == 1) {
std::tie(info->message_ack, header->message_key) = calc_message_ack_and_key(*header, data_size);
if (packet_info->version == 1) {
std::tie(packet_info->message_ack, header->message_key) = calc_message_ack_and_key(*header, data_size);
KDF(auth_key.key(), header->message_key, X, &aes_key, &aes_iv);
} else {
std::tie(info->message_ack, header->message_key) = calc_message_key2(auth_key, X, to_encrypt);
std::tie(packet_info->message_ack, header->message_key) = calc_message_key2(auth_key, X, to_encrypt);
KDF2(auth_key.key(), header->message_key, X, &aes_key, &aes_iv);
}
aes_ige_encrypt(as_slice(aes_key), as_mutable_slice(aes_iv), to_encrypt, to_encrypt);
}
BufferWriter Transport::write_crypto(const Storer &storer, const AuthKey &auth_key, PacketInfo *info,
BufferWriter Transport::write_crypto(const Storer &storer, const AuthKey &auth_key, PacketInfo *packet_info,
size_t prepend_size, size_t append_size) {
size_t data_size = storer.size();
size_t padded_size;
if (info->version == 1) {
if (packet_info->version == 1) {
padded_size = calc_crypto_size<CryptoHeader>(data_size);
} else {
padded_size = calc_crypto_size2<CryptoHeader>(data_size, info);
padded_size = calc_crypto_size2<CryptoHeader>(data_size, packet_info);
}
auto packet = BufferWriter{padded_size, prepend_size, append_size};
//FIXME: rewrite without reinterpret cast
auto &header = *reinterpret_cast<CryptoHeader *>(packet.as_mutable_slice().begin());
header.auth_key_id = auth_key.id();
header.salt = info->salt;
header.session_id = info->session_id;
header.salt = packet_info->salt;
header.session_id = packet_info->session_id;
write_crypto_impl(0, storer, auth_key, info, &header, data_size, padded_size);
write_crypto_impl(0, storer, auth_key, packet_info, &header, data_size, padded_size);
return packet;
}
BufferWriter Transport::write_e2e_crypto(const Storer &storer, const AuthKey &auth_key, PacketInfo *info,
BufferWriter Transport::write_e2e_crypto(const Storer &storer, const AuthKey &auth_key, PacketInfo *packet_info,
size_t prepend_size, size_t append_size) {
size_t data_size = storer.size();
size_t padded_size;
if (info->version == 1) {
if (packet_info->version == 1) {
padded_size = calc_crypto_size<EndToEndHeader>(data_size);
} else {
padded_size = calc_crypto_size2<EndToEndHeader>(data_size, info);
padded_size = calc_crypto_size2<EndToEndHeader>(data_size, packet_info);
}
auto packet = BufferWriter{padded_size, prepend_size, append_size};
@ -400,8 +402,8 @@ BufferWriter Transport::write_e2e_crypto(const Storer &storer, const AuthKey &au
auto &header = *reinterpret_cast<EndToEndHeader *>(packet.as_mutable_slice().begin());
header.auth_key_id = auth_key.id();
write_crypto_impl(info->is_creator || info->version == 1 ? 0 : 8, storer, auth_key, info, &header, data_size,
padded_size);
write_crypto_impl(packet_info->is_creator || packet_info->version == 1 ? 0 : 8, storer, auth_key, packet_info,
&header, data_size, padded_size);
return packet;
}
@ -413,7 +415,7 @@ Result<uint64> Transport::read_auth_key_id(Slice message) {
return as<uint64>(message.begin());
}
Result<Transport::ReadResult> Transport::read(MutableSlice message, const AuthKey &auth_key, PacketInfo *info) {
Result<Transport::ReadResult> Transport::read(MutableSlice message, const AuthKey &auth_key, PacketInfo *packet_info) {
if (message.size() < 12) {
if (message.size() < 4) {
return Status::Error(PSLICE() << "Invalid MTProto message: smaller than 4 bytes [size = " << message.size()
@ -430,31 +432,31 @@ Result<Transport::ReadResult> Transport::read(MutableSlice message, const AuthKe
}
}
info->no_crypto_flag = as<int64>(message.begin()) == 0;
packet_info->no_crypto_flag = as<int64>(message.begin()) == 0;
MutableSlice data;
if (info->type == PacketInfo::EndToEnd) {
TRY_STATUS(read_e2e_crypto(message, auth_key, info, &data));
} else if (info->no_crypto_flag) {
TRY_STATUS(read_no_crypto(message, info, &data));
if (packet_info->type == PacketInfo::EndToEnd) {
TRY_STATUS(read_e2e_crypto(message, auth_key, packet_info, &data));
} else if (packet_info->no_crypto_flag) {
TRY_STATUS(read_no_crypto(message, packet_info, &data));
} else {
if (auth_key.empty()) {
return Status::Error("Failed to decrypt MTProto message: auth key is empty");
}
TRY_STATUS(read_crypto(message, auth_key, info, &data));
TRY_STATUS(read_crypto(message, auth_key, packet_info, &data));
}
return ReadResult::make_packet(data);
}
BufferWriter Transport::write(const Storer &storer, const AuthKey &auth_key, PacketInfo *info, size_t prepend_size,
size_t append_size) {
if (info->type == PacketInfo::EndToEnd) {
return write_e2e_crypto(storer, auth_key, info, prepend_size, append_size);
BufferWriter Transport::write(const Storer &storer, const AuthKey &auth_key, PacketInfo *packet_info,
size_t prepend_size, size_t append_size) {
if (packet_info->type == PacketInfo::EndToEnd) {
return write_e2e_crypto(storer, auth_key, packet_info, prepend_size, append_size);
}
if (info->no_crypto_flag) {
return write_no_crypto(storer, info, prepend_size, append_size);
if (packet_info->no_crypto_flag) {
return write_no_crypto(storer, packet_info, prepend_size, append_size);
} else {
CHECK(!auth_key.empty());
return write_crypto(storer, auth_key, info, prepend_size, append_size);
return write_crypto(storer, auth_key, packet_info, prepend_size, append_size);
}
}

31
td/mtproto/Transport.h
View File

@ -87,10 +87,11 @@ class Transport {
// Returns size of MTProto packet.
// If dest.size() >= size, the packet is also written into [dest].
// If auth_key is nonempty, encryption will be used.
static Result<ReadResult> read(MutableSlice message, const AuthKey &auth_key, PacketInfo *info) TD_WARN_UNUSED_RESULT;
static Result<ReadResult> read(MutableSlice message, const AuthKey &auth_key,
PacketInfo *packet_info) TD_WARN_UNUSED_RESULT;
static BufferWriter write(const Storer &storer, const AuthKey &auth_key, PacketInfo *info, size_t prepend_size = 0,
size_t append_size = 0);
static BufferWriter write(const Storer &storer, const AuthKey &auth_key, PacketInfo *packet_info,
size_t prepend_size = 0, size_t append_size = 0);
// public for testing purposes
static std::pair<uint32, UInt128> calc_message_key2(const AuthKey &auth_key, int X, Slice to_encrypt);
@ -103,33 +104,35 @@ class Transport {
static size_t calc_crypto_size(size_t data_size);
template <class HeaderT>
static size_t calc_crypto_size2(size_t data_size, PacketInfo *info);
static size_t calc_crypto_size2(size_t data_size, PacketInfo *packet_info);
static size_t calc_no_crypto_size(size_t data_size);
static Status read_no_crypto(MutableSlice message, PacketInfo *info, MutableSlice *data) TD_WARN_UNUSED_RESULT;
static Status read_no_crypto(MutableSlice message, PacketInfo *packet_info, MutableSlice *data) TD_WARN_UNUSED_RESULT;
static Status read_crypto(MutableSlice message, const AuthKey &auth_key, PacketInfo *info,
static Status read_crypto(MutableSlice message, const AuthKey &auth_key, PacketInfo *packet_info,
MutableSlice *data) TD_WARN_UNUSED_RESULT;
static Status read_e2e_crypto(MutableSlice message, const AuthKey &auth_key, PacketInfo *info,
static Status read_e2e_crypto(MutableSlice message, const AuthKey &auth_key, PacketInfo *packet_info,
MutableSlice *data) TD_WARN_UNUSED_RESULT;
template <class HeaderT, class PrefixT>
static Status read_crypto_impl(int X, MutableSlice message, const AuthKey &auth_key, HeaderT **header_ptr,
PrefixT **prefix_ptr, MutableSlice *data, PacketInfo *info) TD_WARN_UNUSED_RESULT;
PrefixT **prefix_ptr, MutableSlice *data,
PacketInfo *packet_info) TD_WARN_UNUSED_RESULT;
static BufferWriter write_no_crypto(const Storer &storer, PacketInfo *info, size_t prepend_size, size_t append_size);
static BufferWriter write_crypto(const Storer &storer, const AuthKey &auth_key, PacketInfo *info, size_t prepend_size,
static BufferWriter write_no_crypto(const Storer &storer, PacketInfo *packet_info, size_t prepend_size,
size_t append_size);
static BufferWriter write_e2e_crypto(const Storer &storer, const AuthKey &auth_key, PacketInfo *info,
static BufferWriter write_crypto(const Storer &storer, const AuthKey &auth_key, PacketInfo *packet_info,
size_t prepend_size, size_t append_size);
static BufferWriter write_e2e_crypto(const Storer &storer, const AuthKey &auth_key, PacketInfo *packet_info,
size_t prepend_size, size_t append_size);
template <class HeaderT>
static void write_crypto_impl(int X, const Storer &storer, const AuthKey &auth_key, PacketInfo *info, HeaderT *header,
size_t data_size, size_t padded_size);
static void write_crypto_impl(int X, const Storer &storer, const AuthKey &auth_key, PacketInfo *packet_info,
HeaderT *header, size_t data_size, size_t padded_size);
};
} // namespace mtproto

20
td/telegram/SecretChatActor.cpp
View File

@ -223,11 +223,11 @@ Result<BufferSlice> SecretChatActor::create_encrypted_message(int32 my_in_seq_no
LOG(INFO) << "Create message " << to_string(message_with_layer);
auto storer = create_storer(*message_with_layer);
auto new_storer = mtproto::PacketStorer<SecretImpl>(storer);
mtproto::PacketInfo info;
info.type = mtproto::PacketInfo::EndToEnd;
info.version = 2;
info.is_creator = auth_state_.x == 0;
auto packet_writer = mtproto::Transport::write(new_storer, *auth_key, &info);
mtproto::PacketInfo packet_info;
packet_info.type = mtproto::PacketInfo::EndToEnd;
packet_info.version = 2;
packet_info.is_creator = auth_state_.x == 0;
auto packet_writer = mtproto::Transport::write(new_storer, *auth_key, &packet_info);
message = std::move(message_with_layer->message_);
return packet_writer.as_buffer_slice();
}
@ -792,12 +792,12 @@ Result<std::tuple<uint64, BufferSlice, int32>> SecretChatActor::decrypt(BufferSl
data = encrypted_message_copy.as_mutable_slice();
CHECK(is_aligned_pointer<4>(data.data()));
mtproto::PacketInfo info;
info.type = mtproto::PacketInfo::EndToEnd;
mtproto::PacketInfo packet_info;
packet_info.type = mtproto::PacketInfo::EndToEnd;
mtproto_version = versions[i];
info.version = mtproto_version;
info.is_creator = auth_state_.x == 0;
r_read_result = mtproto::Transport::read(data, *auth_key, &info);
packet_info.version = mtproto_version;
packet_info.is_creator = auth_state_.x == 0;
r_read_result = mtproto::Transport::read(data, *auth_key, &packet_info);
if (i + 1 != versions.size() && r_read_result.is_error()) {
if (config_state_.his_layer >= static_cast<int32>(SecretChatLayer::Mtproto2)) {
LOG(WARNING) << tag("mtproto", mtproto_version) << " decryption failed " << r_read_result.error();