Проблема SSL-подтверждения, возникающая при асинхронном сокете PHP ⇐ Php

[Anonymous]

Хотите задать вопрос, создайте связь следующим образом:
$connection = stream_socket_client(
$address,
$_,
$_,
$timeout,
STREAM_CLIENT_ASYNC_CONNECT | STREAM_CLIENT_CONNECT,
$context
);

И при необходимости установите SSL-соединение следующим образом:
stream_socket_enable_crypto($stream->stream, true, STREAM_CRYPTO_METHOD_SSLv23_CLIENT);
Проблема в том, что «stream_socket_enable_crypto» основан на метаинформации «stream_socket_client» для рукопожатий SSL в случае многоуровневой передачи, такой как
$localStream( socks5://127.0.0.1:1080) www.google.com:443
Если вы используетеstream_socket_enable_crypto для выполнения SSL-квитирования в $localStream, произойдет следующее:
$localStream выполняет подтверждение SSL на основе метаинформации (socks5://127.0.0.1:1080), что означает, что многие сообщения отправляются с целевым подтверждением 127.0.0.1:1080?< /p>
Поэтому в настоящее время, если вы хотите более точно пожать руку для прокси, только без колесаstream_socket_client, с помощью сокета нижнего уровня SOL_SOCKET можно прочитать исходный SOL_SOCKET для выполнения этой задачи. Или мое восприятие узкое
этот исходный класс
use Closure;
use Psc\Core\Coroutine\Exception\Exception;
use Psc\Core\Coroutine\Promise;
use Psc\Core\LibraryAbstract;
use Psc\Core\Stream\Exception\ConnectionException;
use Throwable;

use function Co\cancel;
use function Co\delay;
use function Co\promise;
use function is_array;
use function str_replace;
use function stream_context_create;
use function stream_socket_client;
use function stream_socket_enable_crypto;
use function stream_socket_server;

use const STREAM_CLIENT_ASYNC_CONNECT;
use const STREAM_CLIENT_CONNECT;
use const STREAM_CRYPTO_METHOD_SSLv23_CLIENT;
use const STREAM_SERVER_BIND;
use const STREAM_SERVER_LISTEN;

/**
* @Author cclilshy
* @Date 2024/8/16 09:36
*/
class Socket extends LibraryAbstract
{
/*** @var LibraryAbstract */
protected static LibraryAbstract $instance;

/**
* @param string $address
* @param int $timeout
* @param mixed|null $context
*
* @return SocketStream
* @throws Throwable
*/
public function connectWithSSL(string $address, int $timeout = 0, mixed $context = null): SocketStream
{
return promise(function (Closure $resolve, Closure $reject) use ($address, $timeout, $context) {
$address = str_replace('ssl://', 'tcp://', $address);
$streamSocket = $this->connect($address, $timeout, $context);
$this->enableSSL($streamSocket, $timeout);
})->await();
}

/**
* @param string $address
* @param int $timeout
* @param mixed|null $context
*
* @return SocketStream
* @throws ConnectionException
*/
public function connect(string $address, int $timeout = 0, mixed $context = null): SocketStream
{
try {
return promise(static function (Closure $resolve, Closure $reject) use ($address, $timeout, $context) {
$connection = stream_socket_client(
$address,
$_,
$_,
$timeout,
STREAM_CLIENT_ASYNC_CONNECT | STREAM_CLIENT_CONNECT,
$context
);

if (!$connection) {
$reject(new ConnectionException('Failed to connect to the server.', ConnectionException::CONNECTION_ERROR));
return;
}

$stream = new SocketStream($connection, $address);

if ($timeout > 0) {
$timeoutEventId = delay(static function () use ($stream, $reject) {
$stream->close();
$reject(new ConnectionException('Connection timeout.', ConnectionException::CONNECTION_TIMEOUT));
}, $timeout);
$timeoutEventCancel = fn () => cancel($timeoutEventId);
} else {
$timeoutEventCancel = fn () => null;
}

$stream->onWritable(static function (SocketStream $stream, Closure $cancel) use ($resolve, $timeoutEventCancel) {
$cancel();
$resolve($stream);
$timeoutEventCancel();
});
})->await();
} catch (Throwable $e) {
throw new ConnectionException('Failed to connect to the server.', ConnectionException::CONNECTION_ERROR, $e);
}
}

/**
* @param SocketStream $stream
* @param float $timeout
*
* @return SocketStream
* @throws ConnectionException
*/
public function enableSSL(SocketStream $stream, float $timeout = 0): SocketStream
{
try {
return promise(static function (Closure $resolve, Closure $reject, Promise $promise) use ($stream, $timeout) {
if ($timeout > 0) {
$timeoutEventId = delay(static function () use ($reject) {
$reject(new ConnectionException('SSL handshake timeout.', ConnectionException::CONNECTION_TIMEOUT));
}, $timeout);
$promise->finally(static fn () => cancel($timeoutEventId));
}

$handshakeResult = stream_socket_enable_crypto($stream->stream, true, STREAM_CRYPTO_METHOD_SSLv23_CLIENT);

if ($handshakeResult === false) {
$stream->close();
$reject(new ConnectionException('Failed to enable crypto.', ConnectionException::CONNECTION_CRYPTO));
return;
}

if ($handshakeResult === true) {
$resolve($stream);
return;
}

if ($handshakeResult === 0) {
$stream->onReadable(static function (SocketStream $stream, Closure $cancel) use ($resolve, $reject) {
try {
$handshakeResult = stream_socket_enable_crypto($stream->stream, true, STREAM_CRYPTO_METHOD_SSLv23_CLIENT);
} catch (Throwable $exception) {
$stream->close();
$reject($exception);
return;
}

if ($handshakeResult === false) {
$stream->close();
$reject(new Exception('Failed to enable crypto.'));
return;
}

if ($handshakeResult === true) {
$cancel();
$resolve($stream);
return;
}
});
}
})->await();
} catch (Throwable $e) {
throw new ConnectionException('Failed to enable SSL.', ConnectionException::CONNECTION_CRYPTO, $e);
}
}

/**
* @param string $address
* @param mixed|null $context
*
* @return SocketStream|false
*/
public function server(string $address, mixed $context = null): SocketStream|false
{
if (is_array($context)) {
$context = stream_context_create($context);
}

$server = stream_socket_server(
$address,
$_errCode,
$_errMsg,
STREAM_SERVER_BIND | STREAM_SERVER_LISTEN,
$context
);

return $server ? new SocketStream($server) : false;
}
}


Подробнее здесь: https://stackoverflow.com/questions/790 ... ous-socket