You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
virt/web/tests/CloudS3SignerTest.php

335 lines
13 KiB
PHTML

<?php
require dirname(__DIR__) . '/vendor/autoload.php';
use App\Services\Cloud\CloudObjectStorageS3Client;
use App\Services\Cloud\CloudObjectStorageTestError;
use App\Services\Cloud\CloudObjectStorageTransferError;
use App\Services\Cloud\CloudS3Signer;
use GuzzleHttp\Client;
use GuzzleHttp\Handler\MockHandler;
use GuzzleHttp\HandlerStack;
use GuzzleHttp\Middleware;
use GuzzleHttp\Psr7\Response;
$assert = static function ($condition, string $message): void {
if (!$condition) {
throw new RuntimeException($message);
}
};
$timestamp = strtotime('2013-05-24T00:00:00Z');
$secret = 'wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY';
$expected = 'AWS4-HMAC-SHA256 Credential=AKIAIOSFODNN7EXAMPLE/'
. '20130524/us-east-1/s3/aws4_request,'
. 'SignedHeaders=host;x-amz-content-sha256;x-amz-date,'
. 'Signature=34b48302e7b5fa45bde8084f4b7868a86f0a534bc59db6670ed5711ef69dc6f7';
$headers = CloudS3Signer::sign(
'GET',
'https://examplebucket.s3.amazonaws.com/?max-keys=2&prefix=J',
'us-east-1',
'AKIAIOSFODNN7EXAMPLE',
$secret,
$timestamp
);
$assert($headers['Authorization'] === $expected,
'AWS published Signature Version 4 example no longer matches.');
$reordered = CloudS3Signer::sign(
'GET',
'https://examplebucket.s3.amazonaws.com/?prefix=J&max-keys=2',
'us-east-1',
'AKIAIOSFODNN7EXAMPLE',
$secret,
$timestamp
);
$assert($reordered['Authorization'] === $expected,
'S3 query parameters were not canonicalized before signing.');
$signedMetadata = CloudS3Signer::sign(
'PUT',
'https://examplebucket.s3.amazonaws.com/frozen.qcow2',
'us-east-1',
'AKIAIOSFODNN7EXAMPLE',
$secret,
$timestamp,
str_repeat('a', 64),
['virt-sha256' => str_repeat('b', 64)]
);
$assert(($signedMetadata['x-amz-meta-virt-sha256'] ?? '')
=== str_repeat('b', 64)
&& str_contains(
$signedMetadata['Authorization'],
'SignedHeaders=host;x-amz-content-sha256;x-amz-date;'
. 'x-amz-meta-virt-sha256'
), 'Immutable object SHA metadata was not bound into SigV4.');
try {
CloudS3Signer::sign(
'PUT', 'https://examplebucket.s3.amazonaws.com/frozen.qcow2',
'us-east-1', 'AKIAIOSFODNN7EXAMPLE', $secret, $timestamp,
str_repeat('a', 64), ['virt-sha256' => "forged\nvalue"]
);
throw new RuntimeException('Unsafe S3 metadata was signed.');
} catch (InvalidArgumentException $error) {
$assert(str_contains($error->getMessage(), 'metadata'),
'Unsafe S3 metadata failed with the wrong error.');
}
$presigned = CloudS3Signer::presign(
'GET',
'https://examplebucket.s3.amazonaws.com/test.txt?versionId=3%2FL4kqtJlcpXroDTDmJ%2B3Dc4Rk5w2wTZ',
'us-east-1',
'AKIAIOSFODNN7EXAMPLE',
$secret,
$timestamp,
86400
);
$presignedParts = parse_url($presigned);
parse_str((string) ($presignedParts['query'] ?? ''), $presignedQuery);
$assert(($presignedQuery['X-Amz-Algorithm'] ?? null) === 'AWS4-HMAC-SHA256'
&& ($presignedQuery['X-Amz-Expires'] ?? null) === '86400'
&& ($presignedQuery['X-Amz-SignedHeaders'] ?? null) === 'host'
&& preg_match('/^[a-f0-9]{64}$/D',
(string) ($presignedQuery['X-Amz-Signature'] ?? '')) === 1
&& !str_contains($presigned, $secret),
'S3 presigning did not create a bounded host-only capability URL.');
try {
CloudS3Signer::presign(
'GET', 'https://s3.example.com/object?X-Amz-Date=forged',
'us-east-1', 'ACCESS', 'secret-value', $timestamp, 60
);
throw new RuntimeException('Existing S3 authentication query was accepted.');
} catch (InvalidArgumentException $error) {
$assert(str_contains($error->getMessage(), 'authentication'),
'Existing authentication parameters failed with the wrong error.');
}
$history = [];
$stack = HandlerStack::create(new MockHandler([
new Response(200, ['x-amz-bucket-region' => 'us-east-1']),
]));
$stack->push(Middleware::history($history));
$client = new CloudObjectStorageS3Client(new Client(['handler' => $stack]));
$result = $client->headBucket([
'endpoint' => 'https://minio.example.com:9000',
'region' => 'us-east-1',
'bucket' => 'test-bucket',
'path_style' => true,
], [
'access_key_id' => 'TESTACCESSKEY',
'secret_access_key' => 'test-secret-key-value',
]);
$assert($result['status'] === 'healthy' && count($history) === 1,
'Successful HeadBucket response was not accepted.');
$transaction = $history[0];
$assert($transaction['request']->getMethod() === 'HEAD'
&& (string) $transaction['request']->getUri()
=== 'https://minio.example.com:9000/test-bucket/'
&& str_starts_with($transaction['request']->getHeaderLine('Authorization'),
'AWS4-HMAC-SHA256 ')
&& $transaction['options']['allow_redirects'] === false
&& $transaction['options']['verify'] === true
&& $transaction['options']['proxy'] === '',
'Object-storage check lost its signed, read-only, TLS-strict request contract.');
$denied = new CloudObjectStorageS3Client(new Client([
'handler' => HandlerStack::create(new MockHandler([new Response(403)])),
]));
try {
$denied->headBucket([
'endpoint' => 'https://s3.example.com',
'region' => 'us-east-1',
'bucket' => 'test-bucket',
'path_style' => true,
], [
'access_key_id' => 'TESTACCESSKEY',
'secret_access_key' => 'never-leak-this-secret',
]);
throw new RuntimeException('Denied HeadBucket response was accepted.');
} catch (CloudObjectStorageTestError $error) {
$assert($error->publicCode === 'auth_or_permission_denied'
&& !str_contains($error->getMessage(), 'never-leak'),
'HeadBucket error mapping leaked credentials or changed its stable code.');
}
$multipartHistory = [];
$multipartStack = HandlerStack::create(new MockHandler([
new Response(200, ['Content-Type' => 'application/xml'],
'<?xml version="1.0"?><InitiateMultipartUploadResult>'
. '<UploadId>upload+id/example=</UploadId>'
. '</InitiateMultipartUploadResult>'),
new Response(200, [
'Content-Length' => '123456789',
'ETag' => '"multipart-etag"',
'x-amz-version-id' => 'version-1',
]),
new Response(204),
]));
$multipartStack->push(Middleware::history($multipartHistory));
$multipartClient = new CloudObjectStorageS3Client(new Client([
'handler' => $multipartStack,
]));
$multipartConfig = [
'endpoint' => 'https://objects.example.com:9443',
'region' => 'ewr',
'bucket' => 'backup-bucket',
'path_style' => true,
];
$multipartCredentials = [
'access_key_id' => 'BACKUPACCESSKEY',
'secret_access_key' => 'backup-secret-must-not-leak',
];
$plan = $multipartClient->prepareMultipartUpload(
$multipartConfig,
$multipartCredentials,
'tenant/backups/backup one.qcow2',
128 * 1024 * 1024,
$timestamp,
3600
);
$assert($plan['upload_id'] === 'upload+id/example='
&& $plan['part_size_bytes'] === 64 * 1024 * 1024
&& count($plan['part_urls']) === 2
&& $plan['expires_at'] === $timestamp + 3600,
'Multipart upload plan did not retain its bounded identity and geometry.');
$assert(str_contains($plan['part_urls'][0],
'/backup-bucket/tenant/backups/backup%20one.qcow2?')
&& str_contains($plan['part_urls'][0], 'partNumber=1')
&& str_contains($plan['part_urls'][0], 'uploadId=upload%2Bid%2Fexample%3D')
&& !str_contains(json_encode($plan, JSON_THROW_ON_ERROR),
$multipartCredentials['secret_access_key'])
&& $plan['complete_url'] !== $plan['abort_url']
&& $plan['verify_url'] !== $plan['complete_url']
&& $plan['verify_url'] !== $plan['abort_url']
&& str_contains($plan['verify_url'],
'/backup-bucket/tenant/backups/backup%20one.qcow2?')
&& !str_contains($plan['verify_url'], 'uploadId='),
'Multipart capabilities lost path encoding, method binding, or secret isolation.');
$createRequest = $multipartHistory[0]['request'];
$assert($createRequest->getMethod() === 'POST'
&& str_contains((string) $createRequest->getUri(), 'uploads')
&& str_starts_with($createRequest->getHeaderLine('Authorization'),
'AWS4-HMAC-SHA256 '),
'CreateMultipartUpload did not use a signed control request.');
$head = $multipartClient->headObject(
$multipartConfig, $multipartCredentials,
'tenant/backups/backup one.qcow2'
);
$assert($head === [
'size_bytes' => 123456789,
'sha256' => '',
'etag' => '"multipart-etag"',
'version_id' => 'version-1',
], 'HeadObject did not return the immutable object identity.');
$multipartClient->abortMultipartUpload(
$multipartConfig, $multipartCredentials,
'tenant/backups/backup one.qcow2', 'upload+id/example='
);
$assert($multipartHistory[2]['request']->getMethod() === 'DELETE'
&& str_contains((string) $multipartHistory[2]['request']->getUri(),
'uploadId=upload%2Bid%2Fexample%3D'),
'AbortMultipartUpload did not bind the exact upload identifier.');
$virtualStack = HandlerStack::create(new MockHandler([
new Response(200, [], '<InitiateMultipartUploadResult>'
. '<UploadId>virtual-host-upload</UploadId>'
. '</InitiateMultipartUploadResult>'),
]));
$virtualClient = new CloudObjectStorageS3Client(new Client([
'handler' => $virtualStack,
]));
$virtualPlan = $virtualClient->prepareMultipartUpload([
'endpoint' => 'https://s3.example.com',
'region' => 'us-east-1',
'bucket' => 'virtual-bucket',
'path_style' => false,
], $multipartCredentials, 'vm/a.qcow2', 1, $timestamp, 60);
$assert(str_starts_with($virtualPlan['part_urls'][0],
'https://virtual-bucket.s3.example.com/vm/a.qcow2?'),
'Virtual-host S3 capability used the wrong bucket authority.');
try {
$multipartClient->prepareMultipartUpload(
$multipartConfig, $multipartCredentials, 'too-large.qcow2',
512 * 5368709120 + 1, $timestamp, 60
);
throw new RuntimeException('Oversized multipart control envelope was accepted.');
} catch (InvalidArgumentException $error) {
$assert(str_contains($error->getMessage(), '512-part'),
'Oversized multipart plan failed with the wrong error.');
}
$unknownAbort = new CloudObjectStorageS3Client(new Client([
'handler' => HandlerStack::create(new MockHandler([
new GuzzleHttp\Exception\ConnectException(
'transport down',
new GuzzleHttp\Psr7\Request('DELETE', 'https://s3.example.com')
),
])),
]));
try {
$unknownAbort->abortMultipartUpload([
'endpoint' => 'https://s3.example.com',
'region' => 'us-east-1',
'bucket' => 'bucket',
'path_style' => true,
], $multipartCredentials, 'vm/a.qcow2', 'upload-id');
throw new RuntimeException('Ambiguous abort transport failure was accepted.');
} catch (CloudObjectStorageTransferError $error) {
$assert($error->publicCode === 'multipart_abort_unknown'
&& $error->effectMayHaveApplied
&& !str_contains($error->getMessage(), 'backup-secret'),
'Ambiguous abort did not retain safe unknown-effect semantics.');
}
$deleteHistory = [];
$deleteStack = HandlerStack::create(new MockHandler([
new Response(204),
new Response(200, [
'Content-Length' => '4096',
'ETag' => '"present-etag"',
'x-amz-version-id' => 'present/version+1',
]),
new Response(404),
]));
$deleteStack->push(Middleware::history($deleteHistory));
$deleteClient = new CloudObjectStorageS3Client(new Client([
'handler' => $deleteStack,
]));
$deleteClient->deleteObject(
$multipartConfig, $multipartCredentials, 'vm/delete.qcow2',
'delete/version+1'
);
$assert($deleteClient->objectPresence(
$multipartConfig, $multipartCredentials, 'vm/present.qcow2',
'present/version+1'
) === 'present'
&& $deleteClient->objectPresence(
$multipartConfig, $multipartCredentials, 'vm/absent.qcow2',
'absent/version+1'
) === 'absent'
&& array_map(static fn ($entry): string =>
$entry['request']->getMethod(), $deleteHistory)
=== ['DELETE', 'HEAD', 'HEAD']
&& str_contains((string) $deleteHistory[0]['request']->getUri(),
'versionId=delete%2Fversion%2B1')
&& str_contains((string) $deleteHistory[1]['request']->getUri(),
'versionId=present%2Fversion%2B1'),
'DeleteObject and read-only deletion reconciliation lost method or status semantics.');
$ambiguousDelete = new CloudObjectStorageS3Client(new Client([
'handler' => HandlerStack::create(new MockHandler([new Response(503)])),
]));
try {
$ambiguousDelete->deleteObject(
$multipartConfig, $multipartCredentials, 'vm/ambiguous.qcow2'
);
throw new RuntimeException('Ambiguous DeleteObject response was accepted.');
} catch (CloudObjectStorageTransferError $error) {
$assert($error->publicCode === 'object_delete_unknown'
&& $error->effectMayHaveApplied,
'DeleteObject 5xx did not retain its unknown-effect fence.');
}
echo "S3 Signature Version 4, multipart capabilities and HeadObject contract passed.\n";