andreacavalli/tdlib-fork
Archived
1
0
Fork 0
Code Pull Requests Releases Activity

Various fixes.

Browse Source 
GitOrigin-RevId: e3a710c085e465c44c850db0b41fae19061c2dc5
This commit is contained in:
levlam 2018-04-06 16:26:32 +03:00
parent f7826ec41a
commit 93db75293d
4 changed files with 30 additions and 31 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
td/telegram/PasswordManager.cpp
View File

@ -196,29 +196,27 @@ void PasswordManager::get_full_state(string password, Promise<PasswordFullState>
void PasswordManager::do_get_full_state(string password, PasswordState state, Promise<PasswordFullState> promise) { void PasswordManager::do_get_full_state(string password, PasswordState state, Promise<PasswordFullState> promise) {
auto current_salt = state.current_salt; auto current_salt = state.current_salt;
send_with_promise(G()->net_query_creator().create(create_storer( send_with_promise(
telegram_api::account_getPasswordSettings(calc_password_hash(password, current_salt)))), G()->net_query_creator().create(
PromiseCreator::lambda([promise = std::move(promise), state = std::move(state), create_storer(telegram_api::account_getPasswordSettings(calc_password_hash(password, current_salt)))),
password](Result<NetQueryPtr> r_query) mutable { PromiseCreator::lambda([promise = std::move(promise), state = std::move(state),
promise.set_result([&]() -> Result<PasswordFullState> { password](Result<NetQueryPtr> r_query) mutable {
TRY_RESULT(query, std::move(r_query)); promise.set_result([&]() -> Result<PasswordFullState> {
TRY_RESULT(result, fetch_result<telegram_api::account_getPasswordSettings>(std::move(query))); TRY_RESULT(query, std::move(r_query));
PasswordPrivateState private_state; TRY_RESULT(result, fetch_result<telegram_api::account_getPasswordSettings>(std::move(query)));
private_state.email = result->email_; PasswordPrivateState private_state;
private_state.email = result->email_;
namespace ss = secure_storage; auto r_secret = [&]() -> Result<secure_storage::Secret> {
auto r_secret = [&]() -> Result<ss::Secret> { TRY_RESULT(encrypted_secret, secure_storage::EncryptedSecret::create(result->secure_secret_.as_slice()));
TRY_RESULT(encrypted_secret, ss::EncryptedSecret::create(result->secure_secret_.as_slice())); return encrypted_secret.decrypt(PSLICE() << result->secure_salt_.as_slice() << password
return encrypted_secret.decrypt(PSLICE() << result->secure_salt_.as_slice() << password << result->secure_salt_.as_slice());
<< result->secure_salt_.as_slice()); }();
}();
LOG_IF(ERROR, r_secret.is_error()) << r_secret.error(); private_state.secret = std::move(r_secret);
LOG_IF(ERROR, r_secret.is_ok()) << "HAS SECRET"; return PasswordFullState{std::move(state), std::move(private_state)};
private_state.secret = std::move(r_secret); }());
return PasswordFullState{std::move(state), std::move(private_state)}; }));
}());
}));
} }
void PasswordManager::get_recovery_email_address(string password, void PasswordManager::get_recovery_email_address(string password,

9
td/telegram/SecureStorage.cpp
View File

@ -35,7 +35,7 @@ AesCbcState calc_aes_cbc_state(Slice seed) {
} }
template <class F> template <class F>
Status data_view_for_each(DataView &data, F &&f) { static Status data_view_for_each(DataView &data, F &&f) {
const int64 step = 128 << 10; const int64 step = 128 << 10;
for (int64 i = 0, size = data.size(); i < size; i += step) { for (int64 i = 0, size = data.size(); i < size; i += step) {
TRY_RESULT(bytes, data.pread(i, min(step, size - i))); TRY_RESULT(bytes, data.pread(i, min(step, size - i)));
@ -159,7 +159,7 @@ Result<Secret> Secret::create(Slice secret) {
} }
uint32 checksum = secret_checksum(secret); uint32 checksum = secret_checksum(secret);
if (checksum != 0) { if (checksum != 0) {
return Status::Error(PSLICE() << "Wrong cheksum " << checksum); return Status::Error(PSLICE() << "Wrong checksum " << checksum);
} }
UInt256 res; UInt256 res;
td::as_slice(res).copy_from(secret); td::as_slice(res).copy_from(secret);
@ -206,7 +206,7 @@ Secret::Secret(UInt256 secret, int64 hash) : secret_(secret), hash_(hash) {
//EncryptedSecret //EncryptedSecret
Result<EncryptedSecret> EncryptedSecret::create(Slice encrypted_secret) { Result<EncryptedSecret> EncryptedSecret::create(Slice encrypted_secret) {
if (encrypted_secret.size() != 32) { if (encrypted_secret.size() != 32) {
return Status::Error("Wrong encrypte secret size"); return Status::Error("Wrong encrypted secret size");
} }
UInt256 res; UInt256 res;
td::as_slice(res).copy_from(encrypted_secret); td::as_slice(res).copy_from(encrypted_secret);
@ -242,6 +242,9 @@ Result<BufferSlice> Decryptor::append(BufferSlice data) {
if (!skipped_prefix_) { if (!skipped_prefix_) {
to_skip_ = data.as_slice().ubegin()[0]; to_skip_ = data.as_slice().ubegin()[0];
size_t to_skip = min(to_skip_, data.size()); size_t to_skip = min(to_skip_, data.size());
if (to_skip_ > data.size()) {
to_skip_ = 0; // to fail final to_skip check
}
skipped_prefix_ = true; skipped_prefix_ = true;
data = data.from_slice(data.as_slice().remove_prefix(to_skip)); data = data.from_slice(data.as_slice().remove_prefix(to_skip));
} }

10
td/telegram/SecureValue.cpp
View File

@ -488,9 +488,8 @@ vector<SecureFile> encrypt_secure_files(FileManager *file_manager, const secure_
} }
SecureData encrypt_secure_data(const secure_storage::Secret &master_secret, Slice data, string &to_hash) { SecureData encrypt_secure_data(const secure_storage::Secret &master_secret, Slice data, string &to_hash) {
namespace ss = secure_storage; auto secret = secure_storage::Secret::create_new();
auto secret = ss::Secret::create_new(); auto encrypted = encrypt_value(secret, data).move_as_ok();
auto encrypted = ss::encrypt_value(secret, data).move_as_ok();
SecureData res; SecureData res;
res.encrypted_secret = res.encrypted_secret =
secret.encrypt(PSLICE() << master_secret.as_slice() << encrypted.hash.as_slice()).as_slice().str(); secret.encrypt(PSLICE() << master_secret.as_slice() << encrypted.hash.as_slice()).as_slice().str();
@ -503,21 +502,20 @@ SecureData encrypt_secure_data(const secure_storage::Secret &master_secret, Slic
EncryptedSecureValue encrypt_secure_value(FileManager *file_manager, const secure_storage::Secret &master_secret, EncryptedSecureValue encrypt_secure_value(FileManager *file_manager, const secure_storage::Secret &master_secret,
const SecureValue &secure_value) { const SecureValue &secure_value) {
namespace ss = secure_storage;
EncryptedSecureValue res; EncryptedSecureValue res;
res.type = secure_value.type; res.type = secure_value.type;
switch (res.type) { switch (res.type) {
case SecureValueType::EmailAddress: case SecureValueType::EmailAddress:
case SecureValueType::PhoneNumber: case SecureValueType::PhoneNumber:
res.data = SecureData{secure_value.data, "", ""}; res.data = SecureData{secure_value.data, "", ""};
res.hash = ss::calc_value_hash(secure_value.data).as_slice().str(); res.hash = secure_storage::calc_value_hash(secure_value.data).as_slice().str();
break; break;
default: { default: {
string to_hash; string to_hash;
res.data = encrypt_secure_data(master_secret, secure_value.data, to_hash); res.data = encrypt_secure_data(master_secret, secure_value.data, to_hash);
res.files = encrypt_secure_files(file_manager, master_secret, secure_value.files, to_hash); res.files = encrypt_secure_files(file_manager, master_secret, secure_value.files, to_hash);
res.selfie = encrypt_secure_file(file_manager, master_secret, secure_value.selfie, to_hash); res.selfie = encrypt_secure_file(file_manager, master_secret, secure_value.selfie, to_hash);
res.hash = ss::calc_value_hash(to_hash).as_slice().str(); res.hash = secure_storage::calc_value_hash(to_hash).as_slice().str();
break; break;
} }
} }

2
td/telegram/SecureValue.h
View File

@ -130,7 +130,7 @@ td_api::object_ptr<td_api::encryptedCredentials> get_encrypted_credentials_objec
class SecureValue { class SecureValue {
public: public:
SecureValueType type; SecureValueType type = SecureValueType::None
string data; string data;
vector<FileId> files; vector<FileId> files;
FileId selfie; FileId selfie;