ZaStoGram_desktop/Telegram/SourceFiles/mtproto/proxy/mtproxy/tls_socket.h
loop-uh 6ba2ce7760 Merge upstream Telegram Desktop v7.4.5 beta
Слияние сделал модуль upstream-sync: 9aec590520 (v7.4.5).
Конфликты разбирал ИИ: да.
2026-11-19 21:06:12 +00:00

215 lines
7.7 KiB
C++

/*
This file is part of Telegram Desktop,
the official desktop application for the Telegram messaging service.
For license and copyright information please follow this link:
https://github.com/telegramdesktop/tdesktop/blob/master/LEGAL
*/
#pragma once
#include "mtproto/proxy/mtproxy/client_hello_facts.h"
#include "mtproto/proxy/mtproxy/endpoint_identity.h"
#include "mtproto/proxy/mtproxy/tls_socket_transport.h"
#include "mtproto/proxy/data.h"
#include "mtproto/runtime/runtime_environment.h"
#include "mtproto/transport/details/mtproto_abstract_socket.h"
#include <memory>
namespace MTP {
enum class ProxyDiagnosticsPhase;
enum class ProxyDiagnosticsSeverity;
} // namespace MTP
namespace MTP::details {
class TlsSocket final : public AbstractSocket {
public:
TlsSocket(
not_null<RuntimeEnvironment*> runtime,
not_null<QThread*> thread,
const bytes::vector &secret,
const ProxyData &proxy,
const ProxyStealthOptions &stealth,
ProxyConnectionAttempt mtproxyAttempt,
MtProxyAttemptPlan mtproxyPlan,
crl::time mtproxyAttemptStartedAt,
std::unique_ptr<TlsSocketTransport> transport = nullptr);
~TlsSocket() override;
void connectToHost(const QString &address, int port) override;
bool isGoodStartNonce(bytes::const_span nonce) override;
void timedOut() override;
void markProxyMtprotoPayloadReceived() override;
bool isConnected() override;
bool hasBytesAvailable() override;
int64 read(bytes::span buffer) override;
void write(bytes::const_span prefix, bytes::const_span buffer) override;
int32 debugState() override;
QString debugPostfix() const override;
HandshakePhase handshakePhase() const override;
ProxyMtproxyTerminalReason mtproxyTerminalReason() const override;
crl::time mtproxyTerminalUntil() const override;
ProxyTransportFailure proxyTransportFailure() const override;
private:
enum class State {
NotConnected,
Connecting,
WaitingHello,
Connected,
Error,
};
enum class RecordSizing {
Off,
Conservative,
Varied,
};
enum class StartupCover {
Off,
Soft,
Strict,
};
[[nodiscard]] bytes::const_span domainFromSecret() const;
[[nodiscard]] bytes::const_span keyFromSecret() const;
void plainConnected();
void plainDisconnected();
void plainReadyRead();
void handleError(int errorCode = AbstractConnection::kErrorCodeOther);
void handleError(
MtProxy::FailureReason reason,
int errorCode = AbstractConnection::kErrorCodeOther);
bool finishTerminal(
MtProxy::FailureReason reason,
ProxyConnectionError error,
ProxyCloseOrigin origin,
int errorCode,
const QString &message,
bool emitError);
[[nodiscard]] bool requiredHelloPartReady() const;
void readHello();
void checkHelloParts12(int parts1Size);
void checkHelloParts34(int parts123Size);
void checkHelloDigest();
void readData();
[[nodiscard]] bool checkNextPacket();
void shiftIncomingBy(int amount);
[[nodiscard]] RecordSizing effectiveRecordSizing();
[[nodiscard]] bool startupCoverActive();
[[nodiscard]] int nextRecordPayloadSize();
[[nodiscard]] ProxyTlsProfile effectiveTlsProfile() const;
[[nodiscard]] MtProxy::FailureReason failureReason() const;
bool clearSyntheticPskOnFailure(MtProxy::FailureReason reason);
[[nodiscard]] crl::time recordPacingDelay();
void noteClientHelloClock(TimeId timestamp);
void checkClientHelloContract(const QByteArray &hello);
void writeClientHello(const QByteArray &data);
void writeClientHelloPart(const char *data, int size);
void writeClientHelloTail();
void finishClientHelloWrite();
void armServerHelloDeadline();
void handleServerHelloTimeout();
void sendClientHello();
void sendOutgoing();
void noteIncoming(const QByteArray &data);
void reportTransportEvent(
ProxyDiagnosticsPhase phase,
ProxyDiagnosticsSeverity severity,
const QString &message);
[[nodiscard]] QString responseClass() const;
[[nodiscard]] QString clockReferenceName() const;
[[nodiscard]] QString blockToken() const;
[[nodiscard]] ProxyFailureAttribution failureAttribution() const;
[[nodiscard]] ProxyTransportFailure collectTransportFailure() const;
[[nodiscard]] QString responseRecordType() const;
[[nodiscard]] QString responseRecordVersion() const;
[[nodiscard]] std::optional<int> responseRecordLength() const;
[[nodiscard]] QString responsePrefixHash() const;
const bytes::vector _secret;
const ProxyData _proxy;
MtProxy::EndpointId _endpointId;
QString _endpointKey;
ProxyConnectionUse _endpointUse = ProxyConnectionUse::Main;
ProxyConnectionAttempt _mtproxyAttempt;
MtProxyAttemptPlan _mtproxyPlan;
crl::time _mtproxyAttemptStartedAt = 0;
ProxyStealthOptions _stealth;
std::unique_ptr<TlsSocketTransport> _transport;
State _state = State::NotConnected;
QByteArray _incoming;
QByteArray _responsePrefix;
int _incomingGoodDataOffset = 0;
int _incomingGoodDataLimit = 0;
int _serverHelloLength = 0;
RecordSizing _recordSizing = RecordSizing::Off;
StartupCover _startupCover = StartupCover::Off;
crl::time _startupCoverStartedAt = 0;
int _startupCoverFrames = 0;
bool _firstAppDataSent = false;
ProxyClientHelloFragmentation _clientHelloFragmentation
= ProxyClientHelloFragmentation::Off;
ProxyConnectionPattern _connectionPattern = ProxyConnectionPattern::Off;
ProxyTlsProfile _tlsProfile = ProxyTlsProfile::Auto;
ProxyTlsProfile _configuredTlsProfile = ProxyTlsProfile::Auto;
ProxyTlsProfile _sentTlsProfile = ProxyTlsProfile::Auto;
ProxyTiming _timing = ProxyTiming::Off;
QByteArray _outgoing;
int _outgoingOffset = 0;
bool _clientPrefixSent = false;
bool _syntheticPskOffered = false;
// Whether the hello we sent satisfies everything the relay checks before
// accepting one. A relay never says no - it hands a hello it does not
// recognise to the site it fronts for - so this verdict is what tells an
// unsigned ServerHello caused by our own template apart from one caused by
// a secret that is not the relay's.
ClientHelloContractIssue _clientHelloContract
= ClientHelloContractIssue::None;
// The time that went into the digest, and where it came from. A relay
// refuses anything more than three seconds ahead of its own clock, and
// the client corrects its clock only through channels that bypass the
// proxy - so on the very network where a proxy is needed the correction
// may never arrive. Without knowing whether a reference existed, a skew
// of zero is unreadable: it means either "clock is right" or "we sent the
// raw system clock and have no idea".
TimeId _clientHelloTimestamp = 0;
bool _clockFromMtproto = false;
bool _clockFromHttp = false;
TimeId _clockSkew = 0;
bool _clientHelloFragmented = false;
int _clientHelloBytes = 0;
int _clientHelloWrites = 0;
qint64 _clientHelloAcceptedBytes = 0;
int _clientHelloFragmentSplit = 0;
crl::time _clientHelloFragmentDelayMs = 0;
bool _firstAppDataReceived = false;
bool _mtprotoPayloadReceived = false;
crl::time _firstAppDataAt = 0;
QByteArray _clientHelloTail;
RuntimeTimer _pacingTimer;
RuntimeTimer _clientHelloTimer;
RuntimeTimer _clientHelloFragmentTimer;
RuntimeTimer _serverHelloTimer;
MtProxy::FailureReason _failureReason = MtProxy::FailureReason::None;
ProxyConnectionError _connectionError = ProxyConnectionError::None;
ProxyCloseOrigin _closeOrigin = ProxyCloseOrigin::None;
ProxyTransportFailure _terminalFailure;
qint64 _rxAfterClientHello = 0;
// A report of zero received bytes reads the same whether the answer never
// arrived or arrived and was never handed to us. This counts the times the
// socket said it had something to read, which separates the two.
int _readNotifications = 0;
crl::time _tcpConnectedAt = 0;
crl::time _firstRxAt = 0;
crl::time _serverHelloAt = 0;
crl::time _serverHelloDeadline = 0;
crl::time _terminalAt = 0;
HandshakePhase _phase = HandshakePhase::None;
bool _terminal = false;
};
} // namespace MTP::details