टेलीग्राम पासपोर्ट क्यों - कोई अंत नहीं

हाय% उपयोगकर्ता नाम%!



पासपोर्ट समाचार की चर्चा में , टेलीग्राम के लेखकों से नवीनतम शिल्प की सुरक्षा के बारे में चर्चा हुई।

आइए देखें कि यह आपके व्यक्तिगत डेटा को कैसे एन्क्रिप्ट करता है और वास्तविक एंड-टू-एंड के बारे में बात करता है।

संक्षेप में, पासपोर्ट कैसे काम करता है।

• स्थानीय रूप से, पासवर्ड का उपयोग करके, आप अपने व्यक्तिगत डेटा (नाम, ईमेल, पासपोर्ट स्कैन, अन्य दस्तावेज़) को एन्क्रिप्ट करते हैं।
• एन्क्रिप्टेड डेटा + मेटा-जानकारी को टेलीग्राम क्लाउड पर अपलोड किया जाता है।
• जब आपको सेवा में लॉग इन करने की आवश्यकता होती है, तो क्लाइंट क्लाउड से डेटा डाउनलोड करता है, इसे पासवर्ड के साथ डिक्रिप्ट करता है, इसे उस सेवा की सार्वजनिक कुंजी को डिक्रिप्ट करता है जो जानकारी का अनुरोध करती है, और इसे भेजती है।

हम पहले भाग पर विचार करेंगे, जो व्यक्तिगत डेटा के एन्क्रिप्शन और भंडारण से संबंधित है।

डेवलपर्स के अनुसार एंड टू एंड, इस तथ्य में निहित है कि टेलीग्राम क्लाउड माना जाता है कि आपके व्यक्तिगत डेटा को डिक्रिप्ट नहीं कर सकता है, लेकिन केवल "रैंडम शोर" देखता है।

आइए यहां स्थित डेस्कटॉप क्लाइंट से व्यक्तिगत डेटा के लिए एन्क्रिप्शन एल्गोरिथ्म के कोड पर करीब से नज़र डालें और देखें कि क्या इसके काम का परिणाम एंड-टू-एंड मानदंडों को पूरा करता है।

यह सब एक पासवर्ड से शुरू होता है। यहां वह स्थान है जहां यह एक मध्यवर्ती एन्क्रिप्शन कुंजी में बदल जाता है।

bytes::vector CountPasswordHashForSecret(
		bytes::const_span salt,
		bytes::const_span password) {
	return openssl::Sha512(bytes::concatenate(
		salt,
		password,
		salt));
}

, SHA-512. . !

2018 . GPU SHA-512 . 10 GPU 8- 94 ( , , ) 5 .

, GPU, Telegram .

. , :

bytes::vector GenerateSecretBytes() {
	auto result = bytes::vector(kSecretSize);
	memset_rand(result.data(), result.size());
	const auto full = ranges::accumulate(
		result,
		0ULL,
		[](uint64 sum, gsl::byte value) { return sum + uchar(value); });
	const auto mod = (full % 255ULL);
	const auto add = 255ULL + 239 - mod;
	auto first = (static_cast<uchar>(result[0]) + add) % 255ULL;
	result[0] = static_cast<gsl::byte>(first);
	return result;
}

, .

«», HMAC AEAD , , , 239, :

bool CheckBytesMod255(bytes::const_span bytes) {
	const auto full = ranges::accumulate(
		bytes,
		0ULL,
		[](uint64 sum, gsl::byte value) { return sum + uchar(value); });
	const auto mod = (full % 255ULL);
	return (mod == 239);
}

-, . , , HMAC, .

. , . , :

EncryptedData EncryptData(
		bytes::const_span bytes,
		bytes::const_span dataSecret) {
	constexpr auto kFromPadding = kMinPadding + kAlignTo - 1;
	constexpr auto kPaddingDelta = kMaxPadding - kFromPadding;
	const auto randomPadding = kFromPadding
		+ (rand_value<uint32>() % kPaddingDelta);
	const auto padding = randomPadding
		- ((bytes.size() + randomPadding) % kAlignTo);
	Assert(padding >= kMinPadding && padding <= kMaxPadding);

	auto unencrypted = bytes::vector(padding + bytes.size());
	Assert(unencrypted.size() % kAlignTo == 0);

	unencrypted[0] = static_cast<gsl::byte>(padding);
	memset_rand(unencrypted.data() + 1, padding - 1);
	bytes::copy(
		gsl::make_span(unencrypted).subspan(padding),
		bytes);

32 255 .
dataHash. , .

	const auto dataHash = openssl::Sha256(unencrypted);
	const auto bytesForEncryptionKey = bytes::concatenate(
		dataSecret,
		dataHash);

	auto params = PrepareAesParams(bytesForEncryptionKey);
	return {
		{ dataSecret.begin(), dataSecret.end() },
		{ dataHash.begin(), dataHash.end() },
		Encrypt(unencrypted, std::move(params))
	};
}

. SHA-512 , dataHash.

:

1. ,

« », , , . , AES (2^256).

Telegram , HMAC.

:

1. , (GPU)
2. (AES-NI)
3. .
4. - SHA-512 (GPU)
5. (AES-NI)
6. SHA-256, , :

if (padding < kMinPadding
		|| padding > kMaxPadding
		|| padding > decrypted.size()) {

, , . . GPU, AES-NI. , , . , ?

, , Don't roll your own crypto , End-to-End, .

, , , .

End-to-End

E2E , . , .

, , , , . Signal, (WhatsApp, etc). , , , .

, . .

Telegram , . , , .

P.S. E2E, VirgilSecurity , .