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_; string prime_str_;
BigNum prime_; BigNum prime_;
BigNum g_; BigNum g_;
int32 g_int_; int32 g_int_ = 0;
BigNum b_; BigNum b_;
BigNum g_b_; BigNum g_b_;
BigNum g_a_; BigNum g_a_;

40
td/mtproto/Handshake.cpp
View File

@ -53,7 +53,7 @@ bool AuthKeyHandshake::is_ready_for_start() const {
return state_ == Start; return state_ == Start;
} }
bool AuthKeyHandshake::is_ready_for_message(const UInt128 &message_nonce) const { 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 { bool AuthKeyHandshake::is_ready_for_finish() const {
return state_ == Finish; 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) { 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)); 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"); 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_); auto r_rsa = public_rsa_key->get_rsa(res_pq->server_public_key_fingerprints_);
if (r_rsa.is_error()) { 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"); 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; string data;
switch (mode_) { switch (mode_) {
case Mode::Main: 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; break;
case Mode::Temp: case Mode::Temp:
data = store_object( data = store_object(mtproto_api::p_q_inner_data_temp_dc(res_pq->pq_, p, q, nonce_, server_nonce_, new_nonce_,
mtproto_api::p_q_inner_data_temp_dc(res_pq->pq_, p, q, nonce, server_nonce, new_nonce, dc_id_, expires_in_)); dc_id_, expires_in_));
expires_at_ = Time::now() + expires_in_; expires_at_ = Time::now() + expires_in_;
break; break;
case Mode::Unknown: 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 // req_DH_params#d712e4be nonce:int128 server_nonce:int128 p:string q:string public_key_fingerprint:long
// encrypted_data:string = Server_DH_Params // 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)); send(connection, create_storer(req_dh_params));
state_ = ServerDHParams; 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)); 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; // 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"); 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"); return Status::Error("Server nonce mismatch");
} }
if (dh_params->encrypted_answer_.size() & 15) { if (dh_params->encrypted_answer_.size() & 15) {
return Status::Error("Bad padding for encrypted part"); 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; auto save_tmp_aes_iv = tmp_aes_iv;
// encrypted_answer := AES256_ige_encrypt (answer_with_hash, tmp_aes_key, 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()); 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"); return Status::Error("SHA1 mismatch");
} }
if (dh_inner_data.nonce_ != nonce) { if (dh_inner_data.nonce_ != nonce_) {
return Status::Error("Nonce mismatch"); 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"); 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(); string g_b = handshake.get_g_b();
auto auth_key_params = handshake.gen_key(); 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 = 20 + data.size();
size_t encrypted_data_size_with_pad = (encrypted_data_size + 15) & -16; size_t encrypted_data_size_with_pad = (encrypted_data_size + 15) & -16;
string encrypted_data_str(encrypted_data_size_with_pad, '\0'); 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); encrypted_data.substr(20, data.size()).copy_from(data);
Random::secure_bytes(encrypted_data.ubegin() + encrypted_data_size, Random::secure_bytes(encrypted_data.ubegin() + encrypted_data_size,
encrypted_data_size_with_pad - 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); 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)); send(connection, create_storer(set_client_dh_params));
auth_key_ = AuthKey(auth_key_params.first, std::move(auth_key_params.second)); 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_); 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; state_ = DHGenResponse;
return Status::OK(); return Status::OK();
@ -283,8 +285,8 @@ Status AuthKeyHandshake::on_start(Callback *connection) {
clear(); clear();
return Status::Error(PSLICE() << "on_start called after start " << tag("state", state_)); return Status::Error(PSLICE() << "on_start called after start " << tag("state", state_));
} }
Random::secure_bytes(nonce.raw, sizeof(nonce)); Random::secure_bytes(nonce_.raw, sizeof(nonce_));
send(connection, create_storer(mtproto_api::req_pq_multi(nonce))); send(connection, create_storer(mtproto_api::req_pq_multi(nonce_)));
state_ = ResPQ; state_ = ResPQ;
return Status::OK(); return Status::OK();

8
td/mtproto/Handshake.h
View File

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