tdlight/td/telegram/PasswordManager.cpp

890 lines
42 KiB
C++
Raw Normal View History

//
2024-01-01 01:07:21 +01:00
// Copyright Aliaksei Levin (levlam@telegram.org), Arseny Smirnov (arseny30@gmail.com) 2014-2024
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
#include "td/telegram/PasswordManager.h"
2021-06-23 02:22:23 +02:00
#include "td/telegram/ConfigManager.h"
#include "td/telegram/DhCache.h"
2021-12-09 22:07:59 +01:00
#include "td/telegram/DialogId.h"
#include "td/telegram/Global.h"
#include "td/telegram/logevent/LogEvent.h"
#include "td/telegram/net/NetQueryDispatcher.h"
2021-06-11 01:48:10 +02:00
#include "td/telegram/SuggestedAction.h"
#include "td/telegram/TdDb.h"
#include "td/telegram/telegram_api.h"
#include "td/mtproto/DhHandshake.h"
#include "td/utils/BigNum.h"
#include "td/utils/buffer.h"
#include "td/utils/crypto.h"
#include "td/utils/format.h"
#include "td/utils/logging.h"
#include "td/utils/misc.h"
#include "td/utils/Random.h"
#include "td/utils/Slice.h"
#include "td/utils/SliceBuilder.h"
#include "td/utils/Time.h"
namespace td {
tl_object_ptr<td_api::temporaryPasswordState> TempPasswordState::get_temporary_password_state_object() const {
2023-10-04 11:24:58 +02:00
auto unix_time = G()->unix_time();
if (!has_temp_password || valid_until <= unix_time) {
return make_tl_object<td_api::temporaryPasswordState>(false, 0);
}
2023-10-04 11:24:58 +02:00
return make_tl_object<td_api::temporaryPasswordState>(true, valid_until - unix_time);
}
static void hash_sha256(Slice data, Slice salt, MutableSlice dest) {
sha256(PSLICE() << salt << data << salt, dest);
}
BufferSlice PasswordManager::calc_password_hash(Slice password, Slice client_salt, Slice server_salt) {
LOG(INFO) << "Begin password hash calculation";
BufferSlice buf(32);
hash_sha256(password, client_salt, buf.as_mutable_slice());
hash_sha256(buf.as_slice(), server_salt, buf.as_mutable_slice());
BufferSlice hash(64);
pbkdf2_sha512(buf.as_slice(), client_salt, 100000, hash.as_mutable_slice());
hash_sha256(hash.as_slice(), server_salt, buf.as_mutable_slice());
LOG(INFO) << "End password hash calculation";
return buf;
}
Result<BufferSlice> PasswordManager::calc_password_srp_hash(Slice password, Slice client_salt, Slice server_salt,
int32 g, Slice p) {
LOG(INFO) << "Begin password SRP hash calculation";
TRY_STATUS(mtproto::DhHandshake::check_config(g, p, DhCache::instance()));
auto hash = calc_password_hash(password, client_salt, server_salt);
auto p_bn = BigNum::from_binary(p);
BigNum g_bn;
g_bn.set_value(g);
auto x_bn = BigNum::from_binary(hash.as_slice());
BigNumContext ctx;
BigNum v_bn;
BigNum::mod_exp(v_bn, g_bn, x_bn, p_bn, ctx);
BufferSlice result(v_bn.to_binary(256));
LOG(INFO) << "End password SRP hash calculation";
return std::move(result);
}
tl_object_ptr<telegram_api::InputCheckPasswordSRP> PasswordManager::get_input_check_password(
Slice password, Slice client_salt, Slice server_salt, int32 g, Slice p, Slice B, int64 id) {
if (password.empty()) {
return make_tl_object<telegram_api::inputCheckPasswordEmpty>();
}
if (mtproto::DhHandshake::check_config(g, p, DhCache::instance()).is_error()) {
LOG(ERROR) << "Receive invalid config " << g << " " << format::escaped(p);
return make_tl_object<telegram_api::inputCheckPasswordEmpty>();
}
auto p_bn = BigNum::from_binary(p);
auto B_bn = BigNum::from_binary(B);
auto zero = BigNum::from_decimal("0").move_as_ok();
if (BigNum::compare(zero, B_bn) != -1 || BigNum::compare(B_bn, p_bn) != -1 || B.size() < 248 || B.size() > 256) {
LOG(ERROR) << "Receive invalid value of B(" << B.size() << "): " << B_bn << " " << p_bn;
return make_tl_object<telegram_api::inputCheckPasswordEmpty>();
}
LOG(INFO) << "Begin input password SRP hash calculation";
BigNum g_bn;
g_bn.set_value(g);
auto g_padded = g_bn.to_binary(256);
auto x = calc_password_hash(password, client_salt, server_salt);
auto x_bn = BigNum::from_binary(x.as_slice());
BufferSlice a(2048 / 8);
Random::secure_bytes(a.as_mutable_slice());
auto a_bn = BigNum::from_binary(a.as_slice());
BigNumContext ctx;
BigNum A_bn;
BigNum::mod_exp(A_bn, g_bn, a_bn, p_bn, ctx);
string A = A_bn.to_binary(256);
string B_pad(256 - B.size(), '\0');
string u = sha256(PSLICE() << A << B_pad << B);
auto u_bn = BigNum::from_binary(u);
string k = sha256(PSLICE() << p << g_padded);
auto k_bn = BigNum::from_binary(k);
BigNum v_bn;
BigNum::mod_exp(v_bn, g_bn, x_bn, p_bn, ctx);
BigNum kv_bn;
BigNum::mod_mul(kv_bn, k_bn, v_bn, p_bn, ctx);
BigNum t_bn;
BigNum::sub(t_bn, B_bn, kv_bn);
if (BigNum::compare(t_bn, zero) == -1) {
BigNum::add(t_bn, t_bn, p_bn);
}
BigNum exp_bn;
BigNum::mul(exp_bn, u_bn, x_bn, ctx);
BigNum::add(exp_bn, exp_bn, a_bn);
BigNum S_bn;
BigNum::mod_exp(S_bn, t_bn, exp_bn, p_bn, ctx);
string S = S_bn.to_binary(256);
auto K = sha256(S);
auto h1 = sha256(p);
auto h2 = sha256(g_padded);
for (size_t i = 0; i < h1.size(); i++) {
h1[i] = static_cast<char>(static_cast<unsigned char>(h1[i]) ^ static_cast<unsigned char>(h2[i]));
}
auto M = sha256(PSLICE() << h1 << sha256(client_salt) << sha256(server_salt) << A << B_pad << B << K);
LOG(INFO) << "End input password SRP hash calculation";
return make_tl_object<telegram_api::inputCheckPasswordSRP>(id, BufferSlice(A), BufferSlice(M));
}
tl_object_ptr<telegram_api::InputCheckPasswordSRP> PasswordManager::get_input_check_password(
Slice password, const PasswordState &state) {
return get_input_check_password(password, state.current_client_salt, state.current_server_salt, state.current_srp_g,
state.current_srp_p, state.current_srp_B, state.current_srp_id);
}
void PasswordManager::get_input_check_password_srp(
string password, Promise<tl_object_ptr<telegram_api::InputCheckPasswordSRP>> &&promise) {
do_get_state(PromiseCreator::lambda(
[promise = std::move(promise), password = std::move(password)](Result<PasswordState> r_state) mutable {
if (r_state.is_error()) {
return promise.set_error(r_state.move_as_error());
}
promise.set_value(PasswordManager::get_input_check_password(password, r_state.move_as_ok()));
}));
}
void PasswordManager::set_password(string current_password, string new_password, string new_hint,
bool set_recovery_email_address, string recovery_email_address,
Promise<State> promise) {
UpdateSettings update_settings;
update_settings.current_password = std::move(current_password);
update_settings.update_password = true;
//update_settings.update_secure_secret = true;
update_settings.new_password = std::move(new_password);
update_settings.new_hint = std::move(new_hint);
if (set_recovery_email_address) {
update_settings.update_recovery_email_address = true;
update_settings.recovery_email_address = std::move(recovery_email_address);
}
update_password_settings(std::move(update_settings), std::move(promise));
}
2022-09-07 12:49:48 +02:00
void PasswordManager::set_login_email_address(string new_login_email_address, Promise<SentEmailCode> promise) {
last_set_login_email_address_ = new_login_email_address;
2022-09-07 12:49:48 +02:00
auto query = G()->net_query_creator().create(telegram_api::account_sendVerifyEmailCode(
make_tl_object<telegram_api::emailVerifyPurposeLoginChange>(), std::move(new_login_email_address)));
send_with_promise(std::move(query),
PromiseCreator::lambda([promise = std::move(promise)](Result<NetQueryPtr> r_query) mutable {
auto r_result = fetch_result<telegram_api::account_sendVerifyEmailCode>(std::move(r_query));
if (r_result.is_error()) {
return promise.set_error(r_result.move_as_error());
}
return promise.set_value(SentEmailCode(r_result.move_as_ok()));
}));
}
void PasswordManager::resend_login_email_address_code(Promise<SentEmailCode> promise) {
if (last_set_login_email_address_.empty()) {
return promise.set_error(Status::Error(400, "No login email address code was sent"));
}
set_login_email_address(last_set_login_email_address_, std::move(promise));
}
void PasswordManager::check_login_email_address_code(EmailVerification &&code, Promise<Unit> promise) {
if (last_set_login_email_address_.empty()) {
return promise.set_error(Status::Error(400, "No login email address code was sent"));
}
if (code.is_empty()) {
return promise.set_error(Status::Error(400, "Verification code must be non-empty"));
}
auto query = G()->net_query_creator().create(telegram_api::account_verifyEmail(
make_tl_object<telegram_api::emailVerifyPurposeLoginChange>(), code.get_input_email_verification()));
send_with_promise(std::move(query),
PromiseCreator::lambda([promise = std::move(promise)](Result<NetQueryPtr> r_query) mutable {
auto r_result = fetch_result<telegram_api::account_verifyEmail>(std::move(r_query));
if (r_result.is_error()) {
return promise.set_error(r_result.move_as_error());
}
return promise.set_value(Unit());
}));
}
void PasswordManager::set_recovery_email_address(string password, string new_recovery_email_address,
Promise<State> promise) {
UpdateSettings update_settings;
update_settings.current_password = std::move(password);
update_settings.update_recovery_email_address = true;
update_settings.recovery_email_address = std::move(new_recovery_email_address);
update_password_settings(std::move(update_settings), std::move(promise));
}
void PasswordManager::get_secure_secret(string password, Promise<secure_storage::Secret> promise) {
return do_get_secure_secret(true, std::move(password), std::move(promise));
}
void PasswordManager::do_get_secure_secret(bool allow_recursive, string password,
Promise<secure_storage::Secret> promise) {
if (secret_) {
return promise.set_value(secret_.value().clone());
}
if (password.empty()) {
return promise.set_error(Status::Error(400, "PASSWORD_HASH_INVALID"));
}
get_full_state(
password, PromiseCreator::lambda([actor_id = actor_id(this), password, allow_recursive,
promise = std::move(promise)](Result<PasswordFullState> r_state) mutable {
if (r_state.is_error()) {
return promise.set_error(r_state.move_as_error());
}
auto state = r_state.move_as_ok();
if (!state.state.has_password) {
return promise.set_error(Status::Error(400, "2-step verification is disabled"));
}
if (state.private_state.secret) {
send_closure(actor_id, &PasswordManager::cache_secret, state.private_state.secret.value().clone());
return promise.set_value(std::move(state.private_state.secret.value()));
}
if (!allow_recursive) {
return promise.set_error(Status::Error(400, "Failed to get Telegram Passport secret"));
}
auto new_promise =
PromiseCreator::lambda([actor_id, password, promise = std::move(promise)](Result<bool> r_ok) mutable {
if (r_ok.is_error()) {
return promise.set_error(r_ok.move_as_error());
}
send_closure(actor_id, &PasswordManager::do_get_secure_secret, false, std::move(password),
std::move(promise));
});
UpdateSettings update_settings;
update_settings.current_password = password;
update_settings.update_secure_secret = true;
send_closure(actor_id, &PasswordManager::do_update_password_settings, std::move(update_settings),
std::move(state), std::move(new_promise));
}));
}
void PasswordManager::get_temp_password_state(Promise<TempState> promise) /*const*/ {
promise.set_value(temp_password_state_.get_temporary_password_state_object());
}
TempPasswordState PasswordManager::get_temp_password_state_sync() {
auto temp_password_str = G()->td_db()->get_binlog_pmc()->get("temp_password");
TempPasswordState res;
auto status = log_event_parse(res, temp_password_str);
if (status.is_error() || res.valid_until <= G()->unix_time()) {
res = TempPasswordState();
}
return res;
}
void PasswordManager::create_temp_password(string password, int32 timeout, Promise<TempState> promise) {
if (create_temp_password_promise_) {
return promise.set_error(Status::Error(400, "Another create_temp_password query is active"));
}
create_temp_password_promise_ = std::move(promise);
auto new_promise = PromiseCreator::lambda([actor_id = actor_id(this)](Result<TempPasswordState> result) {
send_closure(actor_id, &PasswordManager::on_finish_create_temp_password, std::move(result), false);
});
do_get_state(PromiseCreator::lambda([actor_id = actor_id(this), password = std::move(password), timeout,
promise = std::move(new_promise)](Result<PasswordState> r_state) mutable {
if (r_state.is_error()) {
return promise.set_error(r_state.move_as_error());
}
send_closure(actor_id, &PasswordManager::do_create_temp_password, std::move(password), timeout,
r_state.move_as_ok(), std::move(promise));
}));
}
void PasswordManager::drop_temp_password() {
G()->td_db()->get_binlog_pmc()->erase("temp_password");
temp_password_state_ = TempPasswordState();
}
void PasswordManager::do_create_temp_password(string password, int32 timeout, PasswordState &&password_state,
Promise<TempPasswordState> promise) {
auto hash = get_input_check_password(password, password_state);
send_with_promise(G()->net_query_creator().create(telegram_api::account_getTmpPassword(std::move(hash), timeout)),
PromiseCreator::lambda([promise = std::move(promise)](Result<NetQueryPtr> r_query) mutable {
auto r_result = fetch_result<telegram_api::account_getTmpPassword>(std::move(r_query));
if (r_result.is_error()) {
return promise.set_error(r_result.move_as_error());
}
auto result = r_result.move_as_ok();
TempPasswordState res;
res.has_temp_password = true;
res.temp_password = result->tmp_password_.as_slice().str();
res.valid_until = result->valid_until_;
promise.set_value(std::move(res));
}));
}
void PasswordManager::on_finish_create_temp_password(Result<TempPasswordState> result, bool /*dummy*/) {
CHECK(create_temp_password_promise_);
if (result.is_error()) {
drop_temp_password();
return create_temp_password_promise_.set_error(result.move_as_error());
}
temp_password_state_ = result.move_as_ok();
G()->td_db()->get_binlog_pmc()->set("temp_password", log_event_store(temp_password_state_).as_slice().str());
create_temp_password_promise_.set_value(temp_password_state_.get_temporary_password_state_object());
}
void PasswordManager::get_full_state(string password, Promise<PasswordFullState> promise) {
2021-06-11 01:48:10 +02:00
send_closure(G()->config_manager(), &ConfigManager::hide_suggested_action,
SuggestedAction{SuggestedAction::Type::CheckPassword});
do_get_state(PromiseCreator::lambda([actor_id = actor_id(this), password = std::move(password),
promise = std::move(promise)](Result<PasswordState> r_state) mutable {
if (r_state.is_error()) {
return promise.set_error(r_state.move_as_error());
}
send_closure(actor_id, &PasswordManager::do_get_full_state, std::move(password), r_state.move_as_ok(),
std::move(promise));
}));
}
Result<secure_storage::Secret> PasswordManager::decrypt_secure_secret(
Slice password, tl_object_ptr<telegram_api::SecurePasswordKdfAlgo> algo_ptr, Slice secret, int64 secret_id) {
TRY_RESULT(encrypted_secret, secure_storage::EncryptedSecret::create(secret));
CHECK(algo_ptr != nullptr);
BufferSlice salt;
secure_storage::EnryptionAlgorithm algorithm = secure_storage::EnryptionAlgorithm::Pbkdf2;
switch (algo_ptr->get_id()) {
case telegram_api::securePasswordKdfAlgoUnknown::ID:
return Status::Error(400, "Unsupported algorithm");
case telegram_api::securePasswordKdfAlgoSHA512::ID: {
auto algo = move_tl_object_as<telegram_api::securePasswordKdfAlgoSHA512>(algo_ptr);
salt = std::move(algo->salt_);
algorithm = secure_storage::EnryptionAlgorithm::Sha512;
break;
}
case telegram_api::securePasswordKdfAlgoPBKDF2HMACSHA512iter100000::ID: {
auto algo = move_tl_object_as<telegram_api::securePasswordKdfAlgoPBKDF2HMACSHA512iter100000>(algo_ptr);
salt = std::move(algo->salt_);
break;
}
default:
UNREACHABLE();
}
TRY_RESULT(result, encrypted_secret.decrypt(password, salt.as_slice(), algorithm));
if (secret_id != result.get_hash()) {
return Status::Error("Secret hash mismatch");
}
return result;
}
void PasswordManager::do_get_full_state(string password, PasswordState state, Promise<PasswordFullState> promise) {
if (!state.has_password) {
PasswordFullState result;
result.state = std::move(state);
return promise.set_value(std::move(result));
}
auto hash = get_input_check_password(password, state);
send_with_promise(G()->net_query_creator().create(telegram_api::account_getPasswordSettings(std::move(hash))),
PromiseCreator::lambda([promise = std::move(promise), state = std::move(state),
password](Result<NetQueryPtr> r_query) mutable {
promise.set_result([&]() -> Result<PasswordFullState> {
TRY_RESULT(result, fetch_result<telegram_api::account_getPasswordSettings>(std::move(r_query)));
LOG(INFO) << "Receive password settings: " << to_string(result);
PasswordPrivateState private_state;
private_state.email = std::move(result->email_);
if (result->secure_settings_ != nullptr) {
auto r_secret =
decrypt_secure_secret(password, std::move(result->secure_settings_->secure_algo_),
result->secure_settings_->secure_secret_.as_slice(),
result->secure_settings_->secure_secret_id_);
if (r_secret.is_ok()) {
private_state.secret = r_secret.move_as_ok();
}
}
return PasswordFullState{std::move(state), std::move(private_state)};
}());
}));
}
void PasswordManager::get_recovery_email_address(string password,
Promise<tl_object_ptr<td_api::recoveryEmailAddress>> promise) {
get_full_state(
password,
PromiseCreator::lambda([password, promise = std::move(promise)](Result<PasswordFullState> r_state) mutable {
if (r_state.is_error()) {
return promise.set_error(r_state.move_as_error());
}
auto state = r_state.move_as_ok();
return promise.set_value(make_tl_object<td_api::recoveryEmailAddress>(state.private_state.email));
}));
}
void PasswordManager::check_recovery_email_address_code(string code, Promise<State> promise) {
auto query = G()->net_query_creator().create(telegram_api::account_confirmPasswordEmail(std::move(code)));
send_with_promise(std::move(query), PromiseCreator::lambda([actor_id = actor_id(this), promise = std::move(promise)](
Result<NetQueryPtr> r_query) mutable {
auto r_result = fetch_result<telegram_api::account_confirmPasswordEmail>(std::move(r_query));
if (r_result.is_error() && r_result.error().message() != "EMAIL_HASH_EXPIRED" &&
r_result.error().message() != "CODE_INVALID") {
return promise.set_error(r_result.move_as_error());
}
send_closure(actor_id, &PasswordManager::get_state, std::move(promise));
}));
}
void PasswordManager::resend_recovery_email_address_code(Promise<State> promise) {
auto query = G()->net_query_creator().create(telegram_api::account_resendPasswordEmail());
send_with_promise(std::move(query), PromiseCreator::lambda([actor_id = actor_id(this), promise = std::move(promise)](
Result<NetQueryPtr> r_query) mutable {
auto r_result = fetch_result<telegram_api::account_resendPasswordEmail>(std::move(r_query));
if (r_result.is_error() && r_result.error().message() != "EMAIL_HASH_EXPIRED") {
return promise.set_error(r_result.move_as_error());
}
send_closure(actor_id, &PasswordManager::get_state, std::move(promise));
}));
}
2022-09-06 13:53:19 +02:00
void PasswordManager::send_email_address_verification_code(string email, Promise<SentEmailCode> promise) {
last_verified_email_address_ = email;
2022-08-08 22:00:06 +02:00
auto query = G()->net_query_creator().create(telegram_api::account_sendVerifyEmailCode(
make_tl_object<telegram_api::emailVerifyPurposePassport>(), std::move(email)));
2022-09-06 13:46:11 +02:00
send_with_promise(std::move(query),
PromiseCreator::lambda([promise = std::move(promise)](Result<NetQueryPtr> r_query) mutable {
auto r_result = fetch_result<telegram_api::account_sendVerifyEmailCode>(std::move(r_query));
if (r_result.is_error()) {
return promise.set_error(r_result.move_as_error());
}
2022-09-06 13:53:19 +02:00
return promise.set_value(SentEmailCode(r_result.move_as_ok()));
2022-09-06 13:46:11 +02:00
}));
}
2022-09-06 13:53:19 +02:00
void PasswordManager::resend_email_address_verification_code(Promise<SentEmailCode> promise) {
if (last_verified_email_address_.empty()) {
return promise.set_error(Status::Error(400, "No email address verification was sent"));
}
send_email_address_verification_code(last_verified_email_address_, std::move(promise));
}
void PasswordManager::check_email_address_verification_code(string code, Promise<Unit> promise) {
if (last_verified_email_address_.empty()) {
return promise.set_error(Status::Error(400, "No email address verification was sent"));
}
2022-08-08 22:00:06 +02:00
auto verification_code = make_tl_object<telegram_api::emailVerificationCode>(std::move(code));
auto query = G()->net_query_creator().create(telegram_api::account_verifyEmail(
make_tl_object<telegram_api::emailVerifyPurposePassport>(), std::move(verification_code)));
send_with_promise(std::move(query),
PromiseCreator::lambda([promise = std::move(promise)](Result<NetQueryPtr> r_query) mutable {
auto r_result = fetch_result<telegram_api::account_verifyEmail>(std::move(r_query));
if (r_result.is_error()) {
return promise.set_error(r_result.move_as_error());
}
return promise.set_value(Unit());
}));
}
2022-09-06 13:53:19 +02:00
void PasswordManager::request_password_recovery(Promise<SentEmailCode> promise) {
2021-06-28 14:55:11 +02:00
// is called only after authorization
2022-09-06 13:46:11 +02:00
send_with_promise(G()->net_query_creator().create(telegram_api::auth_requestPasswordRecovery()),
PromiseCreator::lambda([promise = std::move(promise)](Result<NetQueryPtr> r_query) mutable {
auto r_result = fetch_result<telegram_api::auth_requestPasswordRecovery>(std::move(r_query));
if (r_result.is_error()) {
return promise.set_error(r_result.move_as_error());
}
auto result = r_result.move_as_ok();
2022-09-06 13:53:19 +02:00
return promise.set_value(SentEmailCode(std::move(result->email_pattern_), 0));
2022-09-06 13:46:11 +02:00
}));
}
2021-06-28 22:47:54 +02:00
void PasswordManager::check_password_recovery_code(string code, Promise<Unit> promise) {
// is called only after authorization
send_with_promise(G()->net_query_creator().create(telegram_api::auth_checkRecoveryPassword(code)),
PromiseCreator::lambda([promise = std::move(promise)](Result<NetQueryPtr> r_query) mutable {
auto r_result = fetch_result<telegram_api::auth_checkRecoveryPassword>(std::move(r_query));
if (r_result.is_error()) {
return promise.set_error(r_result.move_as_error());
}
if (!r_result.ok()) {
return promise.set_error(Status::Error(400, "Invalid recovery code"));
}
return promise.set_value(Unit());
}));
}
void PasswordManager::recover_password(string code, string new_password, string new_hint, Promise<State> promise) {
2021-06-28 14:55:11 +02:00
// is called only after authorization
if (new_password.empty()) {
return do_recover_password(std::move(code), nullptr, std::move(promise));
}
UpdateSettings update_settings;
update_settings.update_password = true;
update_settings.new_password = std::move(new_password);
update_settings.new_hint = std::move(new_hint);
do_get_state(PromiseCreator::lambda([actor_id = actor_id(this), code = std::move(code),
update_settings = std::move(update_settings),
promise = std::move(promise)](Result<PasswordState> r_state) mutable {
if (r_state.is_error()) {
return promise.set_error(r_state.move_as_error());
}
2021-06-28 20:03:17 +02:00
TRY_RESULT_PROMISE(
promise, new_settings,
get_password_input_settings(update_settings, r_state.ok().has_password, r_state.ok().new_state, nullptr));
send_closure(actor_id, &PasswordManager::do_recover_password, std::move(code), std::move(new_settings),
std::move(promise));
}));
}
void PasswordManager::do_recover_password(string code, PasswordInputSettings &&new_settings, Promise<State> &&promise) {
int32 flags = 0;
if (new_settings != nullptr) {
flags |= telegram_api::auth_recoverPassword::NEW_SETTINGS_MASK;
}
send_with_promise(G()->net_query_creator().create(
telegram_api::auth_recoverPassword(flags, std::move(code), std::move(new_settings))),
PromiseCreator::lambda(
[actor_id = actor_id(this), promise = std::move(promise)](Result<NetQueryPtr> r_query) mutable {
auto r_result = fetch_result<telegram_api::auth_recoverPassword>(std::move(r_query));
if (r_result.is_error()) {
return promise.set_error(r_result.move_as_error());
}
send_closure(actor_id, &PasswordManager::get_state, std::move(promise));
}));
}
2021-06-29 04:16:48 +02:00
void PasswordManager::reset_password(Promise<ResetPasswordResult> promise) {
send_with_promise(
G()->net_query_creator().create(telegram_api::account_resetPassword()),
PromiseCreator::lambda([promise = std::move(promise)](Result<NetQueryPtr> r_query) mutable {
auto r_result = fetch_result<telegram_api::account_resetPassword>(std::move(r_query));
if (r_result.is_error()) {
return promise.set_error(r_result.move_as_error());
}
auto result_ptr = r_result.move_as_ok();
switch (result_ptr->get_id()) {
case telegram_api::account_resetPasswordOk::ID:
return promise.set_value(td_api::make_object<td_api::resetPasswordResultOk>());
case telegram_api::account_resetPasswordRequestedWait::ID: {
auto result = move_tl_object_as<telegram_api::account_resetPasswordRequestedWait>(result_ptr);
return promise.set_value(td_api::make_object<td_api::resetPasswordResultPending>(result->until_date_));
}
case telegram_api::account_resetPasswordFailedWait::ID: {
auto result = move_tl_object_as<telegram_api::account_resetPasswordFailedWait>(result_ptr);
return promise.set_value(td_api::make_object<td_api::resetPasswordResultDeclined>(result->retry_date_));
}
default:
UNREACHABLE();
break;
}
}));
}
2021-06-30 18:49:52 +02:00
void PasswordManager::cancel_password_reset(Promise<Unit> promise) {
2021-06-29 04:24:55 +02:00
send_with_promise(G()->net_query_creator().create(telegram_api::account_declinePasswordReset()),
PromiseCreator::lambda([promise = std::move(promise)](Result<NetQueryPtr> r_query) mutable {
auto r_result = fetch_result<telegram_api::account_declinePasswordReset>(std::move(r_query));
2021-07-01 02:06:44 +02:00
if (r_result.is_error() && r_result.error().message() != "RESET_REQUEST_MISSING") {
2021-06-29 04:24:55 +02:00
return promise.set_error(r_result.move_as_error());
}
return promise.set_value(Unit());
}));
}
void PasswordManager::update_password_settings(UpdateSettings update_settings, Promise<State> promise) {
auto result_promise = PromiseCreator::lambda(
[actor_id = actor_id(this), promise = std::move(promise)](Result<bool> r_update_settings) mutable {
if (r_update_settings.is_error()) {
return promise.set_error(r_update_settings.move_as_error());
}
if (!r_update_settings.ok()) {
return promise.set_error(Status::Error(400, "account_updatePasswordSettings returned false"));
}
send_closure(actor_id, &PasswordManager::get_state, std::move(promise));
});
auto password = update_settings.current_password;
get_full_state(
std::move(password),
PromiseCreator::lambda([actor_id = actor_id(this), result_promise = std::move(result_promise),
update_settings = std::move(update_settings)](Result<PasswordFullState> r_state) mutable {
if (r_state.is_error()) {
return result_promise.set_error(r_state.move_as_error());
}
send_closure(actor_id, &PasswordManager::do_update_password_settings, std::move(update_settings),
r_state.move_as_ok(), std::move(result_promise));
}));
}
static BufferSlice create_salt(Slice salt_prefix) {
static constexpr size_t ADDED_SALT_SIZE = 32;
BufferSlice new_salt(salt_prefix.size() + ADDED_SALT_SIZE);
new_salt.as_mutable_slice().copy_from(salt_prefix);
Random::secure_bytes(new_salt.as_mutable_slice().substr(salt_prefix.size()));
return new_salt;
}
void PasswordManager::do_update_password_settings(UpdateSettings update_settings, PasswordFullState full_state,
Promise<bool> promise) {
// PasswordState has already been used to get PasswordPrivateState and need to be reget
do_get_state(PromiseCreator::lambda([actor_id = actor_id(this), update_settings = std::move(update_settings),
private_state = std::move(full_state.private_state),
promise = std::move(promise)](Result<PasswordState> r_state) mutable {
if (r_state.is_error()) {
return promise.set_error(r_state.move_as_error());
}
send_closure(actor_id, &PasswordManager::do_update_password_settings_impl, std::move(update_settings),
r_state.move_as_ok(), std::move(private_state), std::move(promise));
}));
}
Result<PasswordManager::PasswordInputSettings> PasswordManager::get_password_input_settings(
string new_password, string new_hint, const NewPasswordState &state) {
UpdateSettings update_settings;
update_settings.update_password = true;
update_settings.new_password = std::move(new_password);
update_settings.new_hint = std::move(new_hint);
return get_password_input_settings(update_settings, true, state, nullptr);
}
Result<PasswordManager::PasswordInputSettings> PasswordManager::get_password_input_settings(
2021-06-28 20:03:17 +02:00
const UpdateSettings &update_settings, bool has_password, const NewPasswordState &state,
const PasswordPrivateState *private_state) {
bool have_secret = private_state != nullptr && private_state->secret;
auto update_secure_secret = update_settings.update_secure_secret;
int32 flags = 0;
BufferSlice new_password_hash;
tl_object_ptr<telegram_api::PasswordKdfAlgo> new_algo;
string new_hint;
if (update_settings.update_password) {
flags |= telegram_api::account_passwordInputSettings::NEW_PASSWORD_HASH_MASK;
flags |= telegram_api::account_passwordInputSettings::NEW_ALGO_MASK;
flags |= telegram_api::account_passwordInputSettings::HINT_MASK;
if (!update_settings.new_password.empty()) {
2021-06-28 20:03:17 +02:00
auto new_client_salt = create_salt(state.client_salt);
auto new_hash = calc_password_srp_hash(update_settings.new_password, new_client_salt.as_slice(),
2021-06-28 20:03:17 +02:00
state.server_salt, state.srp_g, state.srp_p);
if (new_hash.is_error()) {
return Status::Error(400, "Unable to change password, because it may be unsafe");
}
new_password_hash = new_hash.move_as_ok();
new_algo = make_tl_object<telegram_api::passwordKdfAlgoSHA256SHA256PBKDF2HMACSHA512iter100000SHA256ModPow>(
std::move(new_client_salt), BufferSlice(state.server_salt), state.srp_g, BufferSlice(state.srp_p));
2021-10-19 17:11:16 +02:00
new_hint = update_settings.new_hint;
if (have_secret) {
update_secure_secret = true;
}
} else {
new_algo = make_tl_object<telegram_api::passwordKdfAlgoUnknown>();
}
}
// have no password and not setting one
2021-06-28 20:03:17 +02:00
if (!update_settings.update_password && !has_password) {
update_secure_secret = false;
}
// setting an empty password
if (update_settings.update_password && update_settings.new_password.empty()) {
update_secure_secret = false;
}
tl_object_ptr<telegram_api::secureSecretSettings> new_secure_settings;
if (update_secure_secret) {
2021-11-10 19:09:28 +01:00
auto secret = have_secret ? private_state->secret.value() : secure_storage::Secret::create_new();
2021-06-28 20:03:17 +02:00
auto algorithm =
make_tl_object<telegram_api::securePasswordKdfAlgoPBKDF2HMACSHA512iter100000>(create_salt(state.secure_salt));
auto encrypted_secret = secret.encrypt(
update_settings.update_password ? update_settings.new_password : update_settings.current_password,
algorithm->salt_.as_slice(), secure_storage::EnryptionAlgorithm::Pbkdf2);
flags |= telegram_api::account_passwordInputSettings::NEW_SECURE_SETTINGS_MASK;
new_secure_settings = make_tl_object<telegram_api::secureSecretSettings>(
std::move(algorithm), BufferSlice(encrypted_secret.as_slice()), secret.get_hash());
}
if (update_settings.update_recovery_email_address) {
flags |= telegram_api::account_passwordInputSettings::EMAIL_MASK;
}
return make_tl_object<telegram_api::account_passwordInputSettings>(
flags, std::move(new_algo), std::move(new_password_hash), new_hint, update_settings.recovery_email_address,
std::move(new_secure_settings));
}
void PasswordManager::do_update_password_settings_impl(UpdateSettings update_settings, PasswordState state,
PasswordPrivateState private_state, Promise<bool> promise) {
2021-06-28 20:03:17 +02:00
TRY_RESULT_PROMISE(promise, new_settings,
get_password_input_settings(update_settings, state.has_password, state.new_state, &private_state));
auto current_hash = get_input_check_password(state.has_password ? update_settings.current_password : Slice(), state);
auto query = G()->net_query_creator().create(
telegram_api::account_updatePasswordSettings(std::move(current_hash), std::move(new_settings)));
send_with_promise(std::move(query), PromiseCreator::lambda([actor_id = actor_id(this), promise = std::move(promise)](
Result<NetQueryPtr> r_query) mutable {
auto r_result = fetch_result<telegram_api::account_updatePasswordSettings>(std::move(r_query));
if (r_result.is_error()) {
Slice prefix("EMAIL_UNCONFIRMED");
Slice message = r_result.error().message();
if (r_result.error().code() == 400 && begins_with(message, prefix)) {
if (message.size() >= prefix.size() + 2 && message[prefix.size()] == '_') {
send_closure(actor_id, &PasswordManager::on_get_code_length,
to_integer<int32>(message.substr(prefix.size() + 1)));
}
return promise.set_value(true);
}
return promise.set_error(r_result.move_as_error());
}
return promise.set_value(r_result.move_as_ok());
}));
}
void PasswordManager::on_get_code_length(int32 code_length) {
if (code_length <= 0 || code_length > 100) {
LOG(ERROR) << "Receive invalid code length " << code_length;
return;
}
LOG(INFO) << "Set code length to " << code_length;
last_code_length_ = code_length;
}
void PasswordManager::get_state(Promise<State> promise) {
do_get_state(PromiseCreator::lambda([promise = std::move(promise)](Result<PasswordState> r_state) mutable {
if (r_state.is_error()) {
return promise.set_error(r_state.move_as_error());
}
promise.set_value(r_state.move_as_ok().get_password_state_object());
}));
}
void PasswordManager::do_get_state(Promise<PasswordState> promise) {
auto query = G()->net_query_creator().create(telegram_api::account_getPassword());
send_with_promise(
std::move(query), PromiseCreator::lambda([actor_id = actor_id(this), code_length = last_code_length_,
promise = std::move(promise)](Result<NetQueryPtr> r_query) mutable {
TRY_STATUS_PROMISE(promise, G()->close_status());
auto r_result = fetch_result<telegram_api::account_getPassword>(std::move(r_query));
if (r_result.is_error()) {
return promise.set_error(r_result.move_as_error());
}
auto password = r_result.move_as_ok();
LOG(INFO) << "Receive password info: " << to_string(password);
Random::add_seed(password->secure_random_.as_slice());
PasswordState state;
if (password->current_algo_ != nullptr) {
state.has_password = true;
switch (password->current_algo_->get_id()) {
case telegram_api::passwordKdfAlgoUnknown::ID:
return promise.set_error(Status::Error(400, "Please update client to continue"));
case telegram_api::passwordKdfAlgoSHA256SHA256PBKDF2HMACSHA512iter100000SHA256ModPow::ID: {
auto algo =
move_tl_object_as<telegram_api::passwordKdfAlgoSHA256SHA256PBKDF2HMACSHA512iter100000SHA256ModPow>(
password->current_algo_);
state.current_client_salt = algo->salt1_.as_slice().str();
state.current_server_salt = algo->salt2_.as_slice().str();
state.current_srp_g = algo->g_;
state.current_srp_p = algo->p_.as_slice().str();
break;
}
default:
UNREACHABLE();
}
state.current_srp_B = password->srp_B_.as_slice().str();
state.current_srp_id = password->srp_id_;
state.password_hint = std::move(password->hint_);
state.has_recovery_email_address = password->has_recovery_;
state.has_secure_values = password->has_secure_values_;
auto days = narrow_cast<int32>(G()->get_option_integer("otherwise_relogin_days"));
if (days > 0) {
dismiss_suggested_action(SuggestedAction{SuggestedAction::Type::SetPassword, DialogId(), days},
Promise<Unit>());
}
dismiss_suggested_action(SuggestedAction{SuggestedAction::Type::SetPassword}, Promise<Unit>());
} else {
state.has_password = false;
send_closure(actor_id, &PasswordManager::drop_cached_secret);
}
2022-09-06 13:46:11 +02:00
state.unconfirmed_recovery_email_code = {std::move(password->email_unconfirmed_pattern_), code_length};
state.login_email_pattern = std::move(password->login_email_pattern_);
if (password->flags_ & telegram_api::account_password::PENDING_RESET_DATE_MASK) {
state.pending_reset_date = td::max(password->pending_reset_date_, 0);
}
2021-06-28 20:03:17 +02:00
auto &new_state = state.new_state;
TRY_RESULT_PROMISE_ASSIGN(
promise, new_state,
get_new_password_state(std::move(password->new_algo_), std::move(password->new_secure_algo_)));
promise.set_value(std::move(state));
}));
}
void PasswordManager::cache_secret(secure_storage::Secret secret) {
LOG(INFO) << "Cache passport secret";
secret_ = std::move(secret);
const int32 max_cache_time = 3600;
secret_expire_time_ = Time::now() + max_cache_time;
set_timeout_at(secret_expire_time_);
}
void PasswordManager::drop_cached_secret() {
LOG(INFO) << "Drop passport secret";
secret_ = optional<secure_storage::Secret>();
}
void PasswordManager::timeout_expired() {
if (Time::now() >= secret_expire_time_) {
drop_cached_secret();
} else {
set_timeout_at(secret_expire_time_);
}
}
void PasswordManager::on_result(NetQueryPtr query) {
auto token = get_link_token();
container_.extract(token).set_value(std::move(query));
}
void PasswordManager::send_with_promise(NetQueryPtr query, Promise<NetQueryPtr> promise) {
auto id = container_.create(std::move(promise));
G()->net_query_dispatcher().dispatch_with_callback(std::move(query), actor_shared(this, id));
}
void PasswordManager::start_up() {
temp_password_state_ = get_temp_password_state_sync();
}
void PasswordManager::hangup() {
container_.for_each(
2021-10-07 15:36:21 +02:00
[](auto id, Promise<NetQueryPtr> &promise) { promise.set_error(Global::request_aborted_error()); });
stop();
}
} // namespace td