Page MenuHomeWickedGov Phorge

Client.php
No OneTemporary

Size
8 KB
Referenced Files
None
Subscribers
None

Client.php

<?php
namespace Shellbox;
use GuzzleHttp\Psr7\MultipartStream;
use GuzzleHttp\Psr7\Request;
use Psr\Http\Client\ClientInterface;
use Psr\Http\Message\StreamInterface;
use Psr\Http\Message\UriInterface;
use Psr\Log\LoggerInterface;
use Psr\Log\NullLogger;
use ReflectionClass;
use Shellbox\Command\OutputFile;
use Shellbox\Command\OutputFileWithContents;
use Shellbox\Command\OutputGlob;
use Shellbox\Multipart\MultipartReader;
use Shellbox\Multipart\MultipartUtils;
use Shellbox\RPC\RpcClient;
/**
* A generic client which executes actions on the Shellbox server
*/
class Client implements RPCClient {
/** @var ClientInterface */
private $httpClient;
/** @var UriInterface */
private $uri;
/** @var string */
private $key;
/** @var LoggerInterface */
private $logger;
/** @var bool */
private $allowUrlFiles;
/**
* @param ClientInterface $httpClient An object which requests an HTTP resource.
* It is permissible to throw an exception for propagation back to the
* caller. However, a successfully received response with a status code
* of >=400 should ideally be returned to Shellbox as a ResponseInterface,
* so that Shellbox can parse and rethrow its own error messages. With Guzzle
* this could be achieved by passing setting RequestOptions::HTTP_ERROR option
* to false when creating the client.
*
* @param UriInterface $uri The base URI of the server
* @param string $key The key for HMAC authentication
* @param array $options An associative array of options, which may contain:
* - allowUrlFiles: Set this to true to allow input files to be downloaded,
* and output files to be uploaded, on the server side. If this is set,
* the server configuration variable allowUrlFiles must also be set to true.
*/
public function __construct(
ClientInterface $httpClient,
UriInterface $uri,
string $key,
array $options = []
) {
$this->httpClient = $httpClient;
$this->uri = $uri;
$this->key = $key;
$this->logger = new NullLogger;
$this->allowUrlFiles = $options['allowUrlFiles'] ?? false;
}
/**
* @param LoggerInterface $logger
*/
public function setLogger( LoggerInterface $logger ) {
$this->logger = $logger;
}
public function call( $routeName, $functionName, $params = [], $options = [] ) {
$sources = $options['sources'] ?? [];
$binary = !empty( $options['binary'] );
foreach ( $options['classes'] ?? [] as $class ) {
$rc = new ReflectionClass( $class );
$sources[] = $rc->getFileName();
}
$sources = array_unique( $sources );
$parts = [];
$remoteSourceNames = [];
foreach ( $sources as $i => $source ) {
$stream = FileUtils::openInputFileStream( $source );
$remoteSourceName = $i . '_' . basename( $source );
$parts[] = [
'name' => $remoteSourceName,
'headers' => [
'Content-Type' => 'application/x-php',
'Content-Disposition' =>
"attachment; name=\"$remoteSourceName\"; filename=\"$remoteSourceName\"",
],
'contents' => $stream
];
$remoteSourceNames[] = $remoteSourceName;
}
$inputData = [
'action' => 'call',
'functionName' => $functionName,
'sources' => $remoteSourceNames,
'binary' => $binary
];
if ( $binary ) {
foreach ( $params as $i => $param ) {
$parts[] = [
'name' => "param$i",
'contents' => (string)$param
];
}
} else {
$inputData['params'] = $params;
}
$parts[] = [
'name' => 'json-data',
'headers' => [
'Content-Type' => 'application/json',
'Content-Disposition' => 'json-data',
],
'contents' => Shellbox::jsonEncode( $inputData )
];
$outputData = $this->sendRequest( "call/$routeName", $parts );
$this->forwardLog( $outputData['log'] );
return $outputData['returnValue'];
}
/**
* Forward log entries which came to the server to the client's logger.
*
* @param array $entries
*/
private function forwardLog( $entries ) {
foreach ( $entries as $entry ) {
$this->logger->log(
$entry['level'],
$entry['message'],
$entry['context']
);
}
}
/**
* Send an arbitrary request to the server.
*
* @param string $path The URL path relative to the server's base URL
* @param array $parts An array of multipart parts to send, in the format
* specified by MultipartStream. Each part is an associative array
* which for our purposes may contain:
* - "name": The part name. Required but ignored when there is a
* Content-Disposition header.
* - "contents": Here always a StreamInterface or string
* - "headers": An associative array of part headers.
* @param OutputFile[] $outputFiles Output files. The objects will have
* their contents populated with data received from the server.
* @param OutputGlob[] $outputGlobs Output globs. The objects will
* be populated with data received from the server.
* @return array An associative array of output data
* @throws ShellboxError
*/
public function sendRequest( $path, $parts, $outputFiles = [], $outputGlobs = [] ) {
$boundary = Shellbox::getUniqueString();
$bodyStream = new MultipartStream( $parts, $boundary );
$hmac = $this->computeHmac( $bodyStream );
$bodyStream->rewind();
$request = new Request(
'POST',
$this->uri->withPath( $this->uri->getPath() . '/' . $path ),
[
'Content-Type' => "multipart/mixed; boundary=\"$boundary\"",
'Authorization' => "sha256 $hmac"
],
$bodyStream
);
$response = $this->httpClient->sendRequest( $request );
$contentType = $response->getHeaderLine( 'Content-Type' );
if ( $response->getStatusCode() !== 200 ) {
if ( $contentType === 'application/json' ) {
$data = Shellbox::jsonDecode( $response->getBody()->getContents() );
if ( isset( $data['message'] ) && isset( $data['log'] ) ) {
$this->forwardLog( $data['log'] );
throw new ShellboxError( 'Shellbox server error: ' . $data['message'] );
}
}
throw new ShellboxError( "Shellbox server returned status code " .
$response->getStatusCode() );
}
$boundary = MultipartUtils::extractBoundary( $contentType );
if ( $boundary === false ) {
throw new ShellboxError( "Shellbox server returned incorrect Content-Type" );
}
$multipartReader = new MultipartReader( $response->getBody(), $boundary );
$multipartReader->readPreamble();
$data = [];
$outputStrings = [];
$partIndex = 0;
// phpcs:ignore Generic.CodeAnalysis.AssignmentInCondition.FoundInWhileCondition
while ( ( $headers = $multipartReader->readPartHeaders() ) !== false ) {
if ( !isset( $headers['content-disposition'] ) ) {
throw new ShellboxError( "Part #$partIndex has no Content-Disposition" );
}
$disposition = $headers['content-disposition'];
if ( $disposition['type'] === 'json-data' ) {
$data = $multipartReader->readPartAsJson( $headers );
} elseif ( $disposition['type'] === 'form-data' ) {
if ( !isset( $disposition['name'] ) ) {
throw new ShellboxError( "Part #$partIndex has no name" );
}
$outputStrings[$disposition['name']] = $multipartReader->readPartAsString();
} elseif ( $disposition['type'] === 'attachment' ) {
$name = $disposition['name'] ?? '';
if ( isset( $outputFiles[$name] )
&& $outputFiles[$name] instanceof OutputFileWithContents
) {
$outputFiles[$name]->readFromMultipart( $multipartReader );
} else {
$found = false;
foreach ( $outputGlobs as $glob ) {
if ( $glob->isMatch( $name ) ) {
$instance = $glob->getOutputFile( $name );
if ( $instance instanceof OutputFileWithContents ) {
$instance->readFromMultipart( $multipartReader );
$found = true;
break;
}
}
}
if ( !$found ) {
throw new ShellboxError( "Server returned an unexpected file \"$name\"" );
}
}
} else {
throw new ShellboxError( "Unknown content disposition type" );
}
$partIndex++;
}
$multipartReader->readEpilogue();
return $data + $outputStrings;
}
/**
* Read all data from a stream and return its HMAC.
*
* @param StreamInterface $stream
* @return string
*/
private function computeHmac( StreamInterface $stream ) {
$hashContext = hash_init( 'sha256', HASH_HMAC, $this->key );
while ( !$stream->eof() ) {
hash_update( $hashContext, $stream->read( 8192 ) );
}
return hash_final( $hashContext );
}
/**
* Whether the client can download input files and upload output files
* specified with BoxedCommand::inputFileFromUrl and the like.
*
* @since 4.1.0
* @return bool
*/
public function areUrlFilesAllowed() {
return $this->allowUrlFiles;
}
}

File Metadata

Mime Type
text/x-php
Expires
Aug 16 2026, 12:51 (13 w, 4 d ago)
Storage Engine
local-disk
Storage Format
Raw Data
Storage Handle
34/3f/e7be5b93c259d982056229eed741
Default Alt Text
Client.php (8 KB)

Event Timeline