From 4e7b07508f2332920024bd10377c266e9ba3a8b7 Mon Sep 17 00:00:00 2001 From: levlam Date: Thu, 26 Apr 2018 23:41:34 +0300 Subject: [PATCH] Various PassportData fixes. GitOrigin-RevId: 7c8ce3d564c37dcc75715b5dac7886749e0ed9d3 --- td/generate/scheme/td_api.tl | 2 +- td/telegram/MessagesManager.cpp | 2 +- td/telegram/SecureManager.cpp | 17 +++++++++++++---- td/telegram/SecureValue.cpp | 30 ++++++++++++++++++++++++------ td/telegram/cli.cpp | 23 ++++++++++++----------- td/telegram/files/FileLocation.h | 2 +- td/telegram/files/PartsManager.cpp | 16 ++++++++-------- 7 files changed, 60 insertions(+), 32 deletions(-) diff --git a/td/generate/scheme/td_api.tl b/td/generate/scheme/td_api.tl index 7aa7d6d20..21f25ddac 100644 --- a/td/generate/scheme/td_api.tl +++ b/td/generate/scheme/td_api.tl @@ -1804,7 +1804,7 @@ fileTypeSecretThumbnail = FileType; //@description The file is a file from Secure storage used for storing Telegram Passport files fileTypeSecure = FileType; -//@description The file is an encrypted file from Secure storage used for storing Telegram Passport files +//@description The file is an encrypted file from Secure storage used for storing Telegram Passport files; for bots only fileTypeSecureEncrypted = FileType; //@description The file is a sticker diff --git a/td/telegram/MessagesManager.cpp b/td/telegram/MessagesManager.cpp index 00914a553..88a8e7cb9 100644 --- a/td/telegram/MessagesManager.cpp +++ b/td/telegram/MessagesManager.cpp @@ -21494,7 +21494,7 @@ unique_ptr MessagesManager::dup_message_content(DialogId dialog_ if (to_secret && !file_view.is_encrypted_secret()) { auto download_file_id = file_manager->dup_file_id(file_id); file_id = file_manager - ->register_generate(FileType::Encrypted, FileLocationSource::FromServer, "", + ->register_generate(FileType::Encrypted, FileLocationSource::FromServer, file_view.suggested_name(), PSTRING() << "#file_id#" << download_file_id.get(), dialog_id, file_view.size()) .ok(); } diff --git a/td/telegram/SecureManager.cpp b/td/telegram/SecureManager.cpp index 8621bbc95..6cf500f4a 100644 --- a/td/telegram/SecureManager.cpp +++ b/td/telegram/SecureManager.cpp @@ -110,7 +110,7 @@ class SetSecureValue : public NetQueryCallback { void loop() override; void on_result(NetQueryPtr query) override; - void start_upload(FileManager *file_manager, FileId file_id, SecureInputFile &info); + void start_upload(FileManager *file_manager, FileId &file_id, SecureInputFile &info); void merge(FileManager *file_manager, FileId file_id, EncryptedSecureFile &encrypted_file); }; @@ -395,7 +395,16 @@ void SetSecureValue::start_up() { } } -void SetSecureValue::start_upload(FileManager *file_manager, FileId file_id, SecureInputFile &info) { +void SetSecureValue::start_upload(FileManager *file_manager, FileId &file_id, SecureInputFile &info) { + auto file_view = file_manager->get_file_view(file_id); + if (!file_view.is_encrypted_secure()) { + auto download_file_id = file_manager->dup_file_id(file_id); + file_id = file_manager + ->register_generate(FileType::Secure, FileLocationSource::FromServer, file_view.suggested_name(), + PSTRING() << "#file_id#" << download_file_id.get(), DialogId(), file_view.size()) + .ok(); + } + info.file_id = file_manager->dup_file_id(file_id); file_manager->upload(info.file_id, upload_callback_, 1, 0); files_left_to_upload_++; @@ -444,12 +453,12 @@ void SetSecureValue::on_result(NetQueryPtr query) { auto *file_manager = G()->td().get_actor_unsafe()->file_manager_.get(); auto encrypted_secure_value = get_encrypted_secure_value(file_manager, std::move(result)); if (secure_value_.files.size() != encrypted_secure_value.files.size()) { - return on_error(Status::Error("Different files count")); + return on_error(Status::Error(500, "Different file count")); } for (size_t i = 0; i < secure_value_.files.size(); i++) { merge(file_manager, secure_value_.files[i].file_id, encrypted_secure_value.files[i]); } - if (secure_value_.selfie.file_id.is_valid()) { + if (secure_value_.selfie.file_id.is_valid() && encrypted_secure_value.selfie.file.file_id.is_valid()) { merge(file_manager, secure_value_.selfie.file_id, encrypted_secure_value.selfie); } auto r_secure_value = decrypt_secure_value(file_manager, *secret_, encrypted_secure_value); diff --git a/td/telegram/SecureValue.cpp b/td/telegram/SecureValue.cpp index 74221fe8b..86cbfa468 100644 --- a/td/telegram/SecureValue.cpp +++ b/td/telegram/SecureValue.cpp @@ -313,6 +313,10 @@ vector get_encrypted_secure_files(FileManager *file_manager telegram_api::object_ptr get_input_secure_file_object(FileManager *file_manager, const EncryptedSecureFile &file, SecureInputFile &input_file) { + if (!file.file.file_id.is_valid()) { + LOG(ERROR) << "Receive invalid EncryptedSecureFile"; + return nullptr; + } CHECK(file_manager->get_file_view(file.file.file_id).file_id() == file_manager->get_file_view(input_file.file_id).file_id()); auto res = std::move(input_file.input_file); @@ -354,12 +358,15 @@ static vector> get_dated_files_object(File vector> get_input_secure_files_object( FileManager *file_manager, const vector &files, vector &input_files) { CHECK(files.size() == input_files.size()); - vector> res; - res.resize(files.size()); + vector> results; + results.reserve(files.size()); for (size_t i = 0; i < files.size(); i++) { - res[i] = get_input_secure_file_object(file_manager, files[i], input_files[i]); + auto result = get_input_secure_file_object(file_manager, files[i], input_files[i]); + if (result != nullptr) { + results.push_back(std::move(result)); + } } - return res; + return results; } bool operator==(const EncryptedSecureData &lhs, const EncryptedSecureData &rhs) { @@ -1009,11 +1016,11 @@ static EncryptedSecureFile encrypt_secure_file(FileManager *file_manager, const return EncryptedSecureFile(); } if (!file_view.encryption_key().is_secure()) { - LOG(ERROR) << "File has no encryption key"; + LOG(ERROR) << "File " << file.file_id << " has no encryption key"; return EncryptedSecureFile(); } if (!file_view.encryption_key().has_value_hash()) { - LOG(ERROR) << "File has no hash"; + LOG(ERROR) << "File " << file.file_id << " has no hash"; return EncryptedSecureFile(); } auto value_hash = file_view.encryption_key().value_hash(); @@ -1033,6 +1040,17 @@ static vector encrypt_secure_files(FileManager *file_manage vector files, string &to_hash) { return transform( files, [&](auto dated_file) { return encrypt_secure_file(file_manager, master_secret, dated_file, to_hash); }); + /* + vector result; + result.reserve(files.size()); + for (auto &file : files) { + auto encrypted_secure_file = encrypt_secure_file(file_manager, master_secret, file, to_hash); + if (encrypted_secure_file.file.file_id.is_valid()) { + result.push_back(std::move(encrypted_secure_file)); + } + } + return result; +*/ } static EncryptedSecureData encrypt_secure_data(const secure_storage::Secret &master_secret, Slice data, diff --git a/td/telegram/cli.cpp b/td/telegram/cli.cpp index b85b617ba..4376770eb 100644 --- a/td/telegram/cli.cpp +++ b/td/telegram/cli.cpp @@ -2026,7 +2026,7 @@ class CliClient final : public Actor { } } else if (op == "cdf") { send_request(make_tl_object(as_file_id(args), true)); - } else if (op == "uf") { + } else if (op == "uf" || op == "ufs" || op == "ufse" || op == "ufsr") { string file_path; string priority; std::tie(file_path, priority) = split(args); @@ -2034,18 +2034,19 @@ class CliClient final : public Actor { priority = "1"; } - send_request(make_tl_object(as_local_file(file_path), make_tl_object(), - to_integer(priority))); - } else if (op == "ufs") { - string file_path; - string priority; - std::tie(file_path, priority) = split(args); - if (priority.empty()) { - priority = "1"; + td_api::object_ptr type = make_tl_object(); + if (op == "ufs") { + type = make_tl_object(); + } + if (op == "ufse") { + type = make_tl_object(); + } + if (op == "ufsr") { + type = make_tl_object(); } - send_request(make_tl_object( - as_local_file(file_path), make_tl_object(), to_integer(priority))); + send_request( + make_tl_object(as_local_file(file_path), std::move(type), to_integer(priority))); } else if (op == "ufg") { string file_path; string conversion; diff --git a/td/telegram/files/FileLocation.h b/td/telegram/files/FileLocation.h index c4fd4ddc8..c449404d7 100644 --- a/td/telegram/files/FileLocation.h +++ b/td/telegram/files/FileLocation.h @@ -958,7 +958,7 @@ inline bool operator!=(const FullLocalFileLocation &lhs, const FullLocalFileLoca } inline StringBuilder &operator<<(StringBuilder &sb, const FullLocalFileLocation &location) { - return sb << tag("path", location.path_); + return sb << "[" << file_type_name[static_cast(location.file_type_)] << "] at \"" << location.path_ << '"'; } class LocalFileLocation { diff --git a/td/telegram/files/PartsManager.cpp b/td/telegram/files/PartsManager.cpp index 75debb7af..b4435d763 100644 --- a/td/telegram/files/PartsManager.cpp +++ b/td/telegram/files/PartsManager.cpp @@ -17,7 +17,7 @@ namespace td { /*** PartsManager ***/ namespace { -int64 calc_parts_count(int64 size, int64 part_size) { +int64 calc_part_count(int64 size, int64 part_size) { CHECK(part_size != 0); return (size + part_size - 1) / part_size; } @@ -39,7 +39,7 @@ Status PartsManager::init_no_size(size_t part_size, const std::vector &read part_size_ = part_size; } else { part_size_ = 32 * (1 << 10); - while (use_part_count_limit_ && calc_parts_count(expected_size_, part_size_) > MAX_PART_COUNT) { + while (use_part_count_limit_ && calc_part_count(expected_size_, part_size_) > MAX_PART_COUNT) { part_size_ *= 2; CHECK(part_size_ <= MAX_PART_SIZE); } @@ -79,22 +79,22 @@ Status PartsManager::init(int64 size, int64 expected_size, bool is_size_final, s if (part_size != 0) { part_size_ = part_size; - if (use_part_count_limit_ && calc_parts_count(expected_size_, part_size_) > MAX_PART_COUNT) { + if (use_part_count_limit_ && calc_part_count(expected_size_, part_size_) > MAX_PART_COUNT) { return Status::Error("FILE_UPLOAD_RESTART"); } } else { // TODO choose part_size_ depending on size part_size_ = 64 * (1 << 10); - while (use_part_count_limit && calc_parts_count(expected_size_, part_size_) > MAX_PART_COUNT) { + while (use_part_count_limit && calc_part_count(expected_size_, part_size_) > MAX_PART_COUNT) { part_size_ *= 2; CHECK(part_size_ <= MAX_PART_SIZE); } } CHECK(1 <= size_) << tag("size_", size_); - CHECK(!use_part_count_limit || calc_parts_count(expected_size_, part_size_) <= MAX_PART_COUNT) + CHECK(!use_part_count_limit || calc_part_count(expected_size_, part_size_) <= MAX_PART_COUNT) << tag("size_", size_) << tag("expected_size", size_) << tag("is_size_final", is_size_final) << tag("part_size_", part_size_) << tag("ready_parts", ready_parts.size()); - part_count_ = static_cast(calc_parts_count(size_, part_size_)); + part_count_ = static_cast(calc_part_count(size_, part_size_)); init_common(ready_parts); return Status::OK(); @@ -172,7 +172,7 @@ Status PartsManager::set_known_prefix(size_t size, bool is_ready) { CHECK(static_cast(part_count_) == part_status_.size()); if (is_ready) { - part_count_ = static_cast(calc_parts_count(size, part_size_)); + part_count_ = static_cast(calc_part_count(size, part_size_)); size_ = narrow_cast(size); unknown_size_flag_ = false; @@ -182,7 +182,7 @@ Status PartsManager::set_known_prefix(size_t size, bool is_ready) { CHECK(static_cast(part_count_) >= part_status_.size()) << size << " " << is_ready << " " << part_count_ << " " << part_size_ << " " << part_status_.size(); part_status_.resize(part_count_); - if (use_part_count_limit_ && calc_parts_count(expected_size_, part_size_) > MAX_PART_COUNT) { + if (use_part_count_limit_ && calc_part_count(expected_size_, part_size_) > MAX_PART_COUNT) { return Status::Error("FILE_UPLOAD_RESTART"); } return Status::OK();