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

Improve AuthKeyHandshake private field names.

Browse Source
This commit is contained in:
levlam 2021-07-05 21:26:43 +03:00
parent 040e0deb31
commit c60693cc7e
3 changed files with 25 additions and 25 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
td/mtproto/DhHandshake.h
View File

@ -105,7 +105,7 @@ class DhHandshake {
string prime_str_;
BigNum prime_;
BigNum g_;
int32 g_int_;
int32 g_int_ = 0;
BigNum b_;
BigNum g_b_;
BigNum g_a_;

40
td/mtproto/Handshake.cpp
View File

@ -53,7 +53,7 @@ bool AuthKeyHandshake::is_ready_for_start() const {
return state_ == Start;
}
bool AuthKeyHandshake::is_ready_for_message(const UInt128 &message_nonce) const {
return state_ != Finish && state_ != Start && nonce == message_nonce;
return state_ != Finish && state_ != Start && nonce_ == message_nonce;
}
bool AuthKeyHandshake::is_ready_for_finish() const {
return state_ == Finish;
@ -73,11 +73,11 @@ string AuthKeyHandshake::store_object(const mtproto_api::Object &object) {
Status AuthKeyHandshake::on_res_pq(Slice message, Callback *connection, PublicRsaKeyInterface *public_rsa_key) {
TRY_RESULT(res_pq, fetch_result<mtproto_api::req_pq_multi>(message, false));
if (res_pq->nonce_ != nonce) {
if (res_pq->nonce_ != nonce_) {
return Status::Error("Nonce mismatch");
}
server_nonce = res_pq->server_nonce_;
server_nonce_ = res_pq->server_nonce_;
auto r_rsa = public_rsa_key->get_rsa(res_pq->server_public_key_fingerprints_);
if (r_rsa.is_error()) {
@ -92,16 +92,16 @@ Status AuthKeyHandshake::on_res_pq(Slice message, Callback *connection, PublicRs
return Status::Error("Failed to factorize");
}
Random::secure_bytes(new_nonce.raw, sizeof(new_nonce));
Random::secure_bytes(new_nonce_.raw, sizeof(new_nonce_));
string data;
switch (mode_) {
case Mode::Main:
data = store_object(mtproto_api::p_q_inner_data_dc(res_pq->pq_, p, q, nonce, server_nonce, new_nonce, dc_id_));
data = store_object(mtproto_api::p_q_inner_data_dc(res_pq->pq_, p, q, nonce_, server_nonce_, new_nonce_, dc_id_));
break;
case Mode::Temp:
data = store_object(
mtproto_api::p_q_inner_data_temp_dc(res_pq->pq_, p, q, nonce, server_nonce, new_nonce, dc_id_, expires_in_));
data = store_object(mtproto_api::p_q_inner_data_temp_dc(res_pq->pq_, p, q, nonce_, server_nonce_, new_nonce_,
dc_id_, expires_in_));
expires_at_ = Time::now() + expires_in_;
break;
case Mode::Unknown:
@ -127,7 +127,7 @@ Status AuthKeyHandshake::on_res_pq(Slice message, Callback *connection, PublicRs
// req_DH_params#d712e4be nonce:int128 server_nonce:int128 p:string q:string public_key_fingerprint:long
// encrypted_data:string = Server_DH_Params
mtproto_api::req_DH_params req_dh_params(nonce, server_nonce, p, q, rsa_fingerprint, encrypted_data);
mtproto_api::req_DH_params req_dh_params(nonce_, server_nonce_, p, q, rsa_fingerprint, encrypted_data);
send(connection, create_storer(req_dh_params));
state_ = ServerDHParams;
@ -138,17 +138,19 @@ Status AuthKeyHandshake::on_server_dh_params(Slice message, Callback *connection
TRY_RESULT(dh_params, fetch_result<mtproto_api::req_DH_params>(message, false));
// server_DH_params_ok#d0e8075c nonce:int128 server_nonce:int128 encrypted_answer:string = Server_DH_Params;
if (dh_params->nonce_ != nonce) {
if (dh_params->nonce_ != nonce_) {
return Status::Error("Nonce mismatch");
}
if (dh_params->server_nonce_ != server_nonce) {
if (dh_params->server_nonce_ != server_nonce_) {
return Status::Error("Server nonce mismatch");
}
if (dh_params->encrypted_answer_.size() & 15) {
return Status::Error("Bad padding for encrypted part");
}
tmp_KDF(server_nonce, new_nonce, &tmp_aes_key, &tmp_aes_iv);
UInt256 tmp_aes_key;
UInt256 tmp_aes_iv;
tmp_KDF(server_nonce_, new_nonce_, &tmp_aes_key, &tmp_aes_iv);
auto save_tmp_aes_iv = tmp_aes_iv;
// encrypted_answer := AES256_ige_encrypt (answer_with_hash, tmp_aes_key, tmp_aes_iv);
MutableSlice answer(const_cast<char *>(dh_params->encrypted_answer_.begin()), dh_params->encrypted_answer_.size());
@ -179,10 +181,10 @@ Status AuthKeyHandshake::on_server_dh_params(Slice message, Callback *connection
return Status::Error("SHA1 mismatch");
}
if (dh_inner_data.nonce_ != nonce) {
if (dh_inner_data.nonce_ != nonce_) {
return Status::Error("Nonce mismatch");
}
if (dh_inner_data.server_nonce_ != server_nonce) {
if (dh_inner_data.server_nonce_ != server_nonce_) {
return Status::Error("Server nonce mismatch");
}
@ -195,7 +197,7 @@ Status AuthKeyHandshake::on_server_dh_params(Slice message, Callback *connection
string g_b = handshake.get_g_b();
auto auth_key_params = handshake.gen_key();
auto data = store_object(mtproto_api::client_DH_inner_data(nonce, server_nonce, 0, g_b));
auto data = store_object(mtproto_api::client_DH_inner_data(nonce_, server_nonce_, 0, g_b));
size_t encrypted_data_size = 20 + data.size();
size_t encrypted_data_size_with_pad = (encrypted_data_size + 15) & -16;
string encrypted_data_str(encrypted_data_size_with_pad, '\0');
@ -204,10 +206,10 @@ Status AuthKeyHandshake::on_server_dh_params(Slice message, Callback *connection
encrypted_data.substr(20, data.size()).copy_from(data);
Random::secure_bytes(encrypted_data.ubegin() + encrypted_data_size,
encrypted_data_size_with_pad - encrypted_data_size);
tmp_KDF(server_nonce, new_nonce, &tmp_aes_key, &tmp_aes_iv);
tmp_KDF(server_nonce_, new_nonce_, &tmp_aes_key, &tmp_aes_iv);
aes_ige_encrypt(as_slice(tmp_aes_key), as_slice(tmp_aes_iv), encrypted_data, encrypted_data);
mtproto_api::set_client_DH_params set_client_dh_params(nonce, server_nonce, encrypted_data);
mtproto_api::set_client_DH_params set_client_dh_params(nonce_, server_nonce_, encrypted_data);
send(connection, create_storer(set_client_dh_params));
auth_key_ = AuthKey(auth_key_params.first, std::move(auth_key_params.second));
@ -216,7 +218,7 @@ Status AuthKeyHandshake::on_server_dh_params(Slice message, Callback *connection
}
auth_key_.set_created_at(dh_inner_data.server_time_);
server_salt_ = as<int64>(new_nonce.raw) ^ as<int64>(server_nonce.raw);
server_salt_ = as<int64>(new_nonce_.raw) ^ as<int64>(server_nonce_.raw);
state_ = DHGenResponse;
return Status::OK();
@ -283,8 +285,8 @@ Status AuthKeyHandshake::on_start(Callback *connection) {
clear();
return Status::Error(PSLICE() << "on_start called after start " << tag("state", state_));
}
Random::secure_bytes(nonce.raw, sizeof(nonce));
send(connection, create_storer(mtproto_api::req_pq_multi(nonce)));
Random::secure_bytes(nonce_.raw, sizeof(nonce_));
send(connection, create_storer(mtproto_api::req_pq_multi(nonce_)));
state_ = ResPQ;
return Status::OK();

8
td/mtproto/Handshake.h
View File

@ -113,11 +113,9 @@ class AuthKeyHandshake {
double server_time_diff_ = 0;
uint64 server_salt_ = 0;
UInt128 nonce;
UInt128 server_nonce;
UInt256 new_nonce;
UInt256 tmp_aes_key;
UInt256 tmp_aes_iv;
UInt128 nonce_;
UInt128 server_nonce_;
UInt256 new_nonce_;
BufferSlice last_query_;