1046 lines
42 KiB
PHP
1046 lines
42 KiB
PHP
<?php
|
|
|
|
namespace IntegrationTests;
|
|
|
|
require_once __DIR__ . DIRECTORY_SEPARATOR . 'TestIntegration.php';
|
|
|
|
use GuzzleHttp;
|
|
use AlibabaCloud\Oss\V2 as Oss;
|
|
use GuzzleHttp\Psr7\BufferStream;
|
|
use GuzzleHttp\Psr7\LazyOpenStream;
|
|
|
|
|
|
class EncryptionClientTest extends TestIntegration
|
|
{
|
|
const RSA_PUBLIC_KEY = <<<BBB
|
|
-----BEGIN PUBLIC KEY-----
|
|
MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCokfiAVXXf5ImFzKDw+XO/UByW
|
|
6mse2QsIgz3ZwBtMNu59fR5zttSx+8fB7vR4CN3bTztrP9A6bjoN0FFnhlQ3vNJC
|
|
5MFO1PByrE/MNd5AAfSVba93I6sx8NSk5MzUCA4NJzAUqYOEWGtGBcom6kEF6MmR
|
|
1EKib1Id8hpooY5xaQIDAQAB
|
|
-----END PUBLIC KEY-----
|
|
BBB;
|
|
|
|
const RSA_PRIVATE_KEY = <<<BBB
|
|
-----BEGIN PRIVATE KEY-----
|
|
MIICdQIBADANBgkqhkiG9w0BAQEFAASCAl8wggJbAgEAAoGBAKiR+IBVdd/kiYXM
|
|
oPD5c79QHJbqax7ZCwiDPdnAG0w27n19HnO21LH7x8Hu9HgI3dtPO2s/0DpuOg3Q
|
|
UWeGVDe80kLkwU7U8HKsT8w13kAB9JVtr3cjqzHw1KTkzNQIDg0nMBSpg4RYa0YF
|
|
yibqQQXoyZHUQqJvUh3yGmihjnFpAgMBAAECgYA49RmCQ14QyKevDfVTdvYlLmx6
|
|
kbqgMbYIqk+7w611kxoCTMR9VMmJWgmk/Zic9mIAOEVbd7RkCdqT0E+xKzJJFpI2
|
|
ZHjrlwb21uqlcUqH1Gn+wI+jgmrafrnKih0kGucavr/GFi81rXixDrGON9KBE0FJ
|
|
cPVdc0XiQAvCBnIIAQJBANXu3htPH0VsSznfqcDE+w8zpoAJdo6S/p30tcjsDQnx
|
|
l/jYV4FXpErSrtAbmI013VYkdJcghNSLNUXppfk2e8UCQQDJt5c07BS9i2SDEXiz
|
|
byzqCfXVzkdnDj9ry9mba1dcr9B9NCslVelXDGZKvQUBqNYCVxg398aRfWlYDTjU
|
|
IoVVAkAbTyjPN6R4SkC4HJMg5oReBmvkwFCAFsemBk0GXwuzD0IlJAjXnAZ+/rIO
|
|
ItewfwXIL1Mqz53lO/gK+q6TR585AkB304KUIoWzjyF3JqLP3IQOxzns92u9EV6l
|
|
V2P+CkbMPXiZV6sls6I4XppJXX2i3bu7iidN3/dqJ9izQK94fMU9AkBZvgsIPCot
|
|
y1/POIbv9LtnviDKrmpkXgVQSU4BmTPvXwTJm8APC7P/horSh3SVf1zgmnsyjm9D
|
|
hO92gGc+4ajL
|
|
-----END PRIVATE KEY-----
|
|
BBB;
|
|
|
|
const RSA_PUBLIC_KEY1 = <<<BBB
|
|
-----BEGIN PUBLIC KEY-----
|
|
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAzHhuPkhigHeYG0eOFjuX
|
|
nkMP1llge5NlTYxLyU1/jjuWnIgOyZKQHIdIyS2elnzGPFiEY60ywK4R8/erj/Er
|
|
rzY+J3UM4ppgZUuLM+o4i+kYImWX0/ebwjVYpllJMgGJHfcL7tgj1fNvj09WS7WU
|
|
y3TfciDl+Wj13oEnVRwEAiM8+gvqWgOsuu//JbecX73qn/ZPPyQoyylhucpk+y90
|
|
pg80rLlSCeh1odP5IbvGqSudOxemjJq1ChPMu5qOh+QFNPHWh5zrrDRYKdSU4tRq
|
|
FIvmOXSg2Gdp7oyKCxoiDxSJOgAAcPL0pWRyW4Zhhpfc0YU1mRw3LWfXVVgwnmN1
|
|
iQIDAQAB
|
|
-----END PUBLIC KEY-----
|
|
BBB;
|
|
const RSA_PRIVATE_KEY1 = <<<BBB
|
|
-----BEGIN RSA PRIVATE KEY-----
|
|
MIIEpQIBAAKCAQEAzHhuPkhigHeYG0eOFjuXnkMP1llge5NlTYxLyU1/jjuWnIgO
|
|
yZKQHIdIyS2elnzGPFiEY60ywK4R8/erj/ErrzY+J3UM4ppgZUuLM+o4i+kYImWX
|
|
0/ebwjVYpllJMgGJHfcL7tgj1fNvj09WS7WUy3TfciDl+Wj13oEnVRwEAiM8+gvq
|
|
WgOsuu//JbecX73qn/ZPPyQoyylhucpk+y90pg80rLlSCeh1odP5IbvGqSudOxem
|
|
jJq1ChPMu5qOh+QFNPHWh5zrrDRYKdSU4tRqFIvmOXSg2Gdp7oyKCxoiDxSJOgAA
|
|
cPL0pWRyW4Zhhpfc0YU1mRw3LWfXVVgwnmN1iQIDAQABAoIBAQCf98SAU89EpMxK
|
|
42OFf1/ygJL+ZvR2Ge4SiqWsO0aFN5dwpX20NEctGqZWRquhHsNU6QfCl/lyB32i
|
|
Om1t8wfzT2O3KPtIufCar0yb9C4DP/0SxBrRyhGBEo1lr8r1JYBqAiLC3TTEKW1p
|
|
WG+yUcC0oJ5EQvrJc1WQm8jy7DUymYpLTkj+wW5N7qnS7SLI5L2rHfpxMNGIHAs5
|
|
P4gac2E7pQ4f3iLLn2eEx7UZQ1IinW9TAll2QBMZa6ZOVnQsFO3PlnsNAxZ+lfvY
|
|
gqbuhjoYLlAeQkSxsBPqLXss87w2Qw4+NuF0J/ogXSePjv4PFEPIXWYACiCd1Y/x
|
|
47VGprg1AoGBAPSajNcTi0gZGqGvp6ymSNx7i9VHao4gh9Tfyz0bDBiuLOqOXs3N
|
|
4zswcZTfXeK+h95smuudQfRsSK29MR+3kOwN4cG+bKZre5AI1/9t8AkYiZepjhbr
|
|
1z370a2tS5l3tqgZx/zW7tJt0SvYwknqO5ySnvJTPRmuYXg9y2LjtPWnAoGBANX/
|
|
M2bUuGgSCJz81x0njsF7dWXnyps3UpTE0Ck3/Y4DBtBIXMUfhmnUVQa7lPMmcQcn
|
|
/cJGx4NC6g2nUTW49RkKSEr4nsfJ0F73YOTB9iAdZ4QeLkWPz8IMQa1ENCchV/ms
|
|
rEUc7/S9f3la0K+p47LS/g6Z0PO+8+3JSdA1egFPAoGAXLXXfA2kVQdu2KnDW+UK
|
|
6MbLEWOoN4aM9Vp9pgOCajhaPe0Icej/n4eVBWBELZUZ2mw/q95HCWWhhniXDfZ9
|
|
r3rzfoO2mr1ScB1qAR6iRFBQlnNlr7pkMtInfzSX2utNCBn9ew/cJVYKWhwmR+3H
|
|
+mh4ZlC2b+1wdCq31BuKkzECgYEAwFubus1vzayYLXVhcAWE3wq45pdKmedKxgt8
|
|
CfEYbDTwRP0m1tKVoj+JBnpLU520b/hUs/Onl6fod8l0yFOvjYienzWIlJImSZcY
|
|
c8ieExQbXrk6YrD40bbuum7aamogiH/cgmuWjmpgUZd+isitsqrSUBGXr+JvpckQ
|
|
HqZTOyUCgYEArE6eV+kUT/cjY+cbJhHx4VT/+gtPjxncDZayRjdxcHRBn1MLHqHQ
|
|
Db/hHAmtLkR2HWA9DRPhFxflrffBNtJnlOtmA3KL/5a2AdP6hROM8SMe1+DKrOtR
|
|
3JiszMbraILeDMuUD5tk8lwd487gYSxKWAO1NZjGvsum376kn5rUKYM=
|
|
-----END RSA PRIVATE KEY-----
|
|
BBB;
|
|
|
|
public function testPutAndGetObject()
|
|
{
|
|
$client = $this->getDefaultClient();
|
|
$bucketName = self::$bucketName;
|
|
$key = self::randomObjectName();
|
|
$filesize = 25 * 1024 + 123;
|
|
$filename = self::getTempFileName();
|
|
$this->generateFile($filename, $filesize);
|
|
$content = file_get_contents($filename);
|
|
|
|
$masterCipher = new Oss\Crypto\MasterRsaCipher(
|
|
self::RSA_PUBLIC_KEY,
|
|
self::RSA_PRIVATE_KEY,
|
|
['key' => 'value']
|
|
);
|
|
|
|
$eclient = new Oss\EncryptionClient($client, $masterCipher);
|
|
|
|
// put object
|
|
$putObjRequest = new Oss\Models\PutObjectRequest(
|
|
$bucketName,
|
|
$key,
|
|
);
|
|
$putObjRequest->contentMd5 = base64_encode(md5_file($filename, true));
|
|
$putObjRequest->contentLength = $filesize;
|
|
$putObjRequest->body = Oss\Utils::streamFor($content);
|
|
$result = $eclient->putObject($putObjRequest);
|
|
$this->assertEquals(200, $result->statusCode);
|
|
$this->assertEquals('OK', $result->status);
|
|
$this->assertEquals(True, count($result->headers) > 0);
|
|
$this->assertEquals(24, strlen($result->requestId));
|
|
// undec content
|
|
$unDecContent = $this->object_get_contents($client, $bucketName, $key);
|
|
$this->assertEquals($filesize, strlen($unDecContent));
|
|
$this->assertNotEquals($content, $unDecContent);
|
|
|
|
// get object
|
|
$result = $eclient->getObject(new Oss\Models\GetObjectRequest(
|
|
$bucketName,
|
|
$key
|
|
));
|
|
$this->assertEquals(200, $result->statusCode);
|
|
$this->assertEquals('OK', $result->status);
|
|
$this->assertEquals(True, count($result->headers) > 0);
|
|
$this->assertEquals(24, strlen($result->requestId));
|
|
$this->assertEquals($content, $result->body->getContents());
|
|
$this->assertEquals($filesize, $result->contentLength);
|
|
$this->assertEquals(strval($filesize), $result->headers['Content-Length']);
|
|
$this->assertNull($result->contentRange);
|
|
|
|
foreach ([0, 1, 2, 3, 4, 5, 7, 16, 17, 32, 63, 64, 79] as $offset) {
|
|
$request = new Oss\Models\GetObjectRequest(
|
|
$bucketName,
|
|
$key
|
|
);
|
|
$request->rangeHeader = "bytes=$offset-";
|
|
$result = $eclient->getObject($request);
|
|
$this->assertEquals(206, $result->statusCode);
|
|
$this->assertEquals('Partial Content', $result->status);
|
|
$this->assertEquals(substr($content, $offset), $result->body->getContents());
|
|
$this->assertEquals($filesize - $offset, $result->contentLength);
|
|
$this->assertEquals(strval($filesize - $offset), $result->headers['Content-Length']);
|
|
$contentRange = sprintf("bytes %d-%d/%d", $offset, $filesize - 1, $filesize);
|
|
$this->assertEquals($contentRange, $result->contentRange);
|
|
$this->assertEquals($contentRange, $result->headers['Content-Range']);
|
|
}
|
|
|
|
foreach ([0, 1, 2, 17, 32, 63, 79] as $offset) {
|
|
$gotSize = 1234;
|
|
$rangeEnd = $offset + $gotSize - 1;
|
|
$request = new Oss\Models\GetObjectRequest(
|
|
$bucketName,
|
|
$key
|
|
);
|
|
$request->rangeHeader = "bytes=$offset-$rangeEnd";
|
|
$result = $eclient->getObject($request);
|
|
$this->assertEquals(206, $result->statusCode);
|
|
$this->assertEquals('Partial Content', $result->status);
|
|
$this->assertEquals(substr($content, $offset, $gotSize), $result->body->getContents());
|
|
$this->assertEquals($gotSize, $result->contentLength);
|
|
$this->assertEquals(strval($gotSize), $result->headers['Content-Length']);
|
|
$contentRange = sprintf("bytes %d-%d/%d", $offset, $rangeEnd, $filesize);
|
|
$this->assertEquals($contentRange, $result->contentRange);
|
|
$this->assertEquals($contentRange, $result->headers['Content-Range']);
|
|
}
|
|
}
|
|
|
|
public function testPutAndGetObjectWithManyRsa()
|
|
{
|
|
$client = $this->getDefaultClient();
|
|
$bucketName = self::$bucketName;
|
|
$key = self::randomObjectName();
|
|
$filesize = 25 * 1024 + 123;
|
|
$filename = self::getTempFileName();
|
|
$this->generateFile($filename, $filesize);
|
|
$content = file_get_contents($filename);
|
|
|
|
$masterCipher = new Oss\Crypto\MasterRsaCipher(
|
|
self::RSA_PUBLIC_KEY,
|
|
self::RSA_PRIVATE_KEY,
|
|
['demo1']
|
|
);
|
|
|
|
$masterCipher2 = new Oss\Crypto\MasterRsaCipher(
|
|
self::RSA_PUBLIC_KEY1,
|
|
self::RSA_PRIVATE_KEY1,
|
|
['demo2']
|
|
);
|
|
|
|
$eclient = new Oss\EncryptionClient($client, $masterCipher2, [$masterCipher, $masterCipher2]);
|
|
|
|
// put object
|
|
$putObjRequest = new Oss\Models\PutObjectRequest(
|
|
$bucketName,
|
|
$key,
|
|
);
|
|
$putObjRequest->contentMd5 = base64_encode(md5_file($filename, true));
|
|
$putObjRequest->contentLength = $filesize;
|
|
$putObjRequest->body = Oss\Utils::streamFor($content);
|
|
$result = $eclient->putObject($putObjRequest);
|
|
$this->assertEquals(200, $result->statusCode);
|
|
$this->assertEquals('OK', $result->status);
|
|
$this->assertEquals(True, count($result->headers) > 0);
|
|
$this->assertEquals(24, strlen($result->requestId));
|
|
// undec content
|
|
$unDecContent = $this->object_get_contents($client, $bucketName, $key);
|
|
$this->assertEquals($filesize, strlen($unDecContent));
|
|
$this->assertNotEquals($content, $unDecContent);
|
|
|
|
// get object
|
|
$result = $eclient->getObject(new Oss\Models\GetObjectRequest(
|
|
$bucketName,
|
|
$key
|
|
));
|
|
$this->assertEquals(200, $result->statusCode);
|
|
$this->assertEquals('OK', $result->status);
|
|
$this->assertEquals(True, count($result->headers) > 0);
|
|
$this->assertEquals(24, strlen($result->requestId));
|
|
$this->assertEquals($content, $result->body->getContents());
|
|
$this->assertEquals($filesize, $result->contentLength);
|
|
$this->assertEquals(strval($filesize), $result->headers['Content-Length']);
|
|
$this->assertNull($result->contentRange);
|
|
|
|
foreach ([0, 1, 2, 3, 4, 5, 7, 16, 17, 32, 63, 64, 79] as $offset) {
|
|
$request = new Oss\Models\GetObjectRequest(
|
|
$bucketName,
|
|
$key
|
|
);
|
|
$request->rangeHeader = "bytes=$offset-";
|
|
$result = $eclient->getObject($request);
|
|
$this->assertEquals(206, $result->statusCode);
|
|
$this->assertEquals('Partial Content', $result->status);
|
|
$this->assertEquals(substr($content, $offset), $result->body->getContents());
|
|
$this->assertEquals($filesize - $offset, $result->contentLength);
|
|
$this->assertEquals(strval($filesize - $offset), $result->headers['Content-Length']);
|
|
$contentRange = sprintf("bytes %d-%d/%d", $offset, $filesize - 1, $filesize);
|
|
$this->assertEquals($contentRange, $result->contentRange);
|
|
$this->assertEquals($contentRange, $result->headers['Content-Range']);
|
|
}
|
|
|
|
foreach ([0, 1, 2, 17, 32, 63, 79] as $offset) {
|
|
$gotSize = 1234;
|
|
$rangeEnd = $offset + $gotSize - 1;
|
|
$request = new Oss\Models\GetObjectRequest(
|
|
$bucketName,
|
|
$key
|
|
);
|
|
$request->rangeHeader = "bytes=$offset-$rangeEnd";
|
|
$result = $eclient->getObject($request);
|
|
$this->assertEquals(206, $result->statusCode);
|
|
$this->assertEquals('Partial Content', $result->status);
|
|
$this->assertEquals(substr($content, $offset, $gotSize), $result->body->getContents());
|
|
$this->assertEquals($gotSize, $result->contentLength);
|
|
$this->assertEquals(strval($gotSize), $result->headers['Content-Length']);
|
|
$contentRange = sprintf("bytes %d-%d/%d", $offset, $rangeEnd, $filesize);
|
|
$this->assertEquals($contentRange, $result->contentRange);
|
|
$this->assertEquals($contentRange, $result->headers['Content-Range']);
|
|
}
|
|
}
|
|
|
|
public function testGetObjectStreamMode()
|
|
{
|
|
$client = $this->getDefaultClient();
|
|
$bucketName = self::$bucketName;
|
|
$key = self::randomObjectName();
|
|
$filesize = 250 * 1024 + 123;
|
|
$filename = self::getTempFileName();
|
|
$this->generateFile($filename, $filesize);
|
|
$content = file_get_contents($filename);
|
|
|
|
$masterCipher = new Oss\Crypto\MasterRsaCipher(
|
|
self::RSA_PUBLIC_KEY,
|
|
self::RSA_PRIVATE_KEY,
|
|
['key' => 'value']
|
|
);
|
|
|
|
$eclient = new Oss\EncryptionClient($client, $masterCipher);
|
|
|
|
// put object
|
|
$putObjRequest = new Oss\Models\PutObjectRequest(
|
|
$bucketName,
|
|
$key,
|
|
);
|
|
$putObjRequest->body = Oss\Utils::streamFor($content);
|
|
$result = $eclient->putObject($putObjRequest);
|
|
$this->assertEquals(200, $result->statusCode);
|
|
$this->assertEquals('OK', $result->status);
|
|
$this->assertEquals(True, count($result->headers) > 0);
|
|
$this->assertEquals(24, strlen($result->requestId));
|
|
$this->assertNotEquals($content, $this->object_get_contents($client, $bucketName, $key));
|
|
|
|
// get object
|
|
$args = [
|
|
'request_options' =>
|
|
['stream' => true]
|
|
];
|
|
$result = $eclient->getObject(
|
|
new Oss\Models\GetObjectRequest(
|
|
$bucketName,
|
|
$key
|
|
),
|
|
$args
|
|
);
|
|
$this->assertEquals(200, $result->statusCode);
|
|
$this->assertEquals('OK', $result->status);
|
|
$this->assertEquals(True, count($result->headers) > 0);
|
|
$this->assertEquals(24, strlen($result->requestId));
|
|
$this->assertFalse($result->body->isSeekable());
|
|
$this->assertInstanceOf(Oss\Crypto\ReadDecryptStream::class, $result->body);
|
|
$this->assertEquals($content, $result->body->getContents());
|
|
$this->assertEquals($filesize, $result->contentLength);
|
|
$this->assertEquals(strval($filesize), $result->headers['Content-Length']);
|
|
$this->assertNull($result->contentRange);
|
|
$this->assertCount(1, $args['request_options']);
|
|
|
|
// range get
|
|
$args = [
|
|
'request_options' =>
|
|
['stream' => true]
|
|
];
|
|
$request = new Oss\Models\GetObjectRequest(
|
|
$bucketName,
|
|
$key
|
|
);
|
|
$offset = 12345;
|
|
$gotSize = 22234;
|
|
$rangeEnd = $offset + $gotSize - 1;
|
|
$request->rangeHeader = sprintf("bytes=%d-%d", $offset, $rangeEnd);
|
|
$result = $eclient->getObject($request, $args);
|
|
$this->assertEquals(206, $result->statusCode);
|
|
$this->assertEquals('Partial Content', $result->status);
|
|
$this->assertEquals(True, count($result->headers) > 0);
|
|
$this->assertEquals(24, strlen($result->requestId));
|
|
$this->assertFalse($result->body->isSeekable());
|
|
$this->assertInstanceOf(Oss\Crypto\ReadDecryptStream::class, $result->body);
|
|
$this->assertEquals(substr($content, $offset, $gotSize), $result->body->getContents());
|
|
$this->assertEquals($gotSize, $result->contentLength);
|
|
$this->assertEquals(strval($gotSize), $result->headers['Content-Length']);
|
|
$contentRange = sprintf("bytes %d-%d/%d", $offset, $rangeEnd, $filesize);
|
|
$this->assertEquals($contentRange, $result->contentRange);
|
|
$this->assertCount(1, $args['request_options']);
|
|
}
|
|
|
|
public function testHeadObject()
|
|
{
|
|
$client = $this->getDefaultClient();
|
|
$bucketName = self::$bucketName;
|
|
$key = self::randomObjectName();
|
|
$filesize = 25 * 1024 + 123;
|
|
$filename = self::getTempFileName();
|
|
$this->generateFile($filename, $filesize);
|
|
$content = file_get_contents($filename);
|
|
|
|
$masterCipher = new Oss\Crypto\MasterRsaCipher(
|
|
self::RSA_PUBLIC_KEY,
|
|
self::RSA_PRIVATE_KEY,
|
|
['key' => 'value']
|
|
);
|
|
|
|
$eclient = new Oss\EncryptionClient($client, $masterCipher);
|
|
|
|
// put object
|
|
$putObjRequest = new Oss\Models\PutObjectRequest(
|
|
$bucketName,
|
|
$key,
|
|
);
|
|
$putObjRequest->body = Oss\Utils::streamFor($content);
|
|
$result = $eclient->putObject($putObjRequest);
|
|
$this->assertEquals(200, $result->statusCode);
|
|
$this->assertEquals('OK', $result->status);
|
|
$this->assertEquals(True, count($result->headers) > 0);
|
|
$this->assertEquals(24, strlen($result->requestId));
|
|
|
|
// head object
|
|
$result = $eclient->headObject(new Oss\Models\HeadObjectRequest(
|
|
$bucketName,
|
|
$key
|
|
));
|
|
$this->assertEquals(200, $result->statusCode);
|
|
$this->assertEquals('OK', $result->status);
|
|
$this->assertEquals(True, count($result->headers) > 0);
|
|
$this->assertEquals(24, strlen($result->requestId));
|
|
$this->assertNotEmpty($result->metadata['client-side-encryption-key']);
|
|
$this->assertNotEmpty($result->metadata['client-side-encryption-start']);
|
|
$this->assertEquals('AES/CTR/NoPadding', $result->metadata['client-side-encryption-cek-alg']);
|
|
$this->assertEquals('RSA/NONE/PKCS1Padding', $result->metadata['client-side-encryption-wrap-alg']);
|
|
$this->assertEquals('{"key":"value"}', $result->metadata['client-side-encryption-matdesc']);
|
|
}
|
|
|
|
public function testGetObjectMeta()
|
|
{
|
|
$client = $this->getDefaultClient();
|
|
$bucketName = self::$bucketName;
|
|
$key = self::randomObjectName();
|
|
$filesize = 25 * 1024 + 123;
|
|
$filename = self::getTempFileName();
|
|
$this->generateFile($filename, $filesize);
|
|
$content = file_get_contents($filename);
|
|
|
|
$masterCipher = new Oss\Crypto\MasterRsaCipher(
|
|
self::RSA_PUBLIC_KEY,
|
|
self::RSA_PRIVATE_KEY,
|
|
['key' => 'value']
|
|
);
|
|
|
|
$eclient = new Oss\EncryptionClient($client, $masterCipher);
|
|
|
|
// put object
|
|
$putObjRequest = new Oss\Models\PutObjectRequest(
|
|
$bucketName,
|
|
$key,
|
|
);
|
|
$putObjRequest->body = Oss\Utils::streamFor($content);
|
|
$result = $eclient->putObject($putObjRequest);
|
|
$this->assertEquals(200, $result->statusCode);
|
|
$this->assertEquals('OK', $result->status);
|
|
$this->assertEquals(True, count($result->headers) > 0);
|
|
$this->assertEquals(24, strlen($result->requestId));
|
|
|
|
// get object meta
|
|
$result = $eclient->getObjectMeta(new Oss\Models\GetObjectMetaRequest(
|
|
$bucketName,
|
|
$key
|
|
));
|
|
$this->assertEquals(200, $result->statusCode);
|
|
$this->assertEquals('OK', $result->status);
|
|
$this->assertEquals(True, count($result->headers) > 0);
|
|
$this->assertEquals(24, strlen($result->requestId));
|
|
$this->assertEquals(strlen($content), $result->contentLength);
|
|
}
|
|
|
|
public function testObjectMultipart()
|
|
{
|
|
$client = $this->getDefaultClient();
|
|
$bucketName = self::$bucketName;
|
|
$key = self::randomObjectName() . '-multipart';
|
|
$masterCipher = new Oss\Crypto\MasterRsaCipher(
|
|
self::RSA_PUBLIC_KEY,
|
|
self::RSA_PRIVATE_KEY,
|
|
['key' => 'value']
|
|
);
|
|
$eclient = new Oss\EncryptionClient($client, $masterCipher);
|
|
$partSize = 200 * 1024;
|
|
$length = 500 * 1024;
|
|
$bigFileName = self::getTempFileName() . "-bigfile.tmp";
|
|
$this->generateFile($bigFileName, $length);
|
|
try {
|
|
$initRequest = new Oss\Models\InitiateMultipartUploadRequest(
|
|
$bucketName,
|
|
$key,
|
|
);
|
|
$initRequest->cseDataSize = $length;
|
|
$initRequest->csePartSize = $partSize;
|
|
$initRequest->contentMd5 = base64_encode(md5_file($bigFileName, true));
|
|
$initRequest->contentLength = $length;
|
|
$initResult = $eclient->initiateMultipartUpload(
|
|
$initRequest
|
|
);
|
|
$this->assertEquals(200, $initResult->statusCode);
|
|
$this->assertNotEmpty($initResult->uploadId);
|
|
$file = fopen($bigFileName, 'r');
|
|
$parts = array();
|
|
if ($file) {
|
|
$i = 1;
|
|
while (!feof($file)) {
|
|
$chunk = fread($file, $partSize);
|
|
$partRequest = new Oss\Models\UploadPartRequest(
|
|
$bucketName,
|
|
$key,
|
|
$i,
|
|
$initResult->uploadId,
|
|
strlen($chunk),
|
|
null,
|
|
null,
|
|
null,
|
|
Oss\Utils::streamFor($chunk)
|
|
);
|
|
$partRequest->encryptionMultipartContext = $initResult->encryptionMultipartContext;
|
|
$partResult = $eclient->uploadPart($partRequest);
|
|
$this->assertEquals(200, $partResult->statusCode);
|
|
$part = new Oss\Models\UploadPart(
|
|
$i,
|
|
$partResult->etag,
|
|
);
|
|
array_push($parts, $part);
|
|
$i++;
|
|
}
|
|
fclose($file);
|
|
}
|
|
$comResult = $eclient->completeMultipartUpload(
|
|
new Oss\Models\CompleteMultipartUploadRequest(
|
|
$bucketName,
|
|
$key,
|
|
$initResult->uploadId,
|
|
null,
|
|
new Oss\Models\CompleteMultipartUpload(
|
|
$parts
|
|
),
|
|
)
|
|
);
|
|
$this->assertEquals(200, $comResult->statusCode);
|
|
$this->assertEquals($bucketName, $comResult->bucket);
|
|
$this->assertEquals($key, $comResult->key);
|
|
$this->assertNotEmpty($comResult->etag);
|
|
$this->assertNotEmpty($comResult->location);
|
|
$getObj = $eclient->getObject(new Oss\Models\GetObjectRequest(
|
|
$bucketName,
|
|
$key,
|
|
));
|
|
$this->assertEquals(base64_encode(md5(file_get_contents($bigFileName), true)), base64_encode(md5($getObj->body, true)));
|
|
} catch (\Throwable $e) {
|
|
$this->assertTrue(false, "should not here");
|
|
}
|
|
|
|
try {
|
|
$initRequest = new Oss\Models\InitiateMultipartUploadRequest(
|
|
$bucketName,
|
|
$key,
|
|
);
|
|
$initRequest->cseDataSize = $length;
|
|
$initRequest->csePartSize = $partSize;
|
|
$initResult = $eclient->initiateMultipartUpload(
|
|
$initRequest
|
|
);
|
|
$this->assertEquals(200, $initResult->statusCode);
|
|
$this->assertNotEmpty($initResult->uploadId);
|
|
$file = fopen($bigFileName, 'r');
|
|
$parts = array();
|
|
if ($file) {
|
|
$i = 1;
|
|
while (!feof($file)) {
|
|
$chunk = fread($file, $partSize);
|
|
$partRequest = new Oss\Models\UploadPartRequest(
|
|
$bucketName,
|
|
$key,
|
|
$i,
|
|
$initResult->uploadId,
|
|
strlen($chunk),
|
|
null,
|
|
null,
|
|
null,
|
|
Oss\Utils::streamFor($chunk)
|
|
);
|
|
$partRequest->contentMd5 = base64_encode(md5($chunk, true));
|
|
$partRequest->encryptionMultipartContext = $initResult->encryptionMultipartContext;
|
|
$partResult = $eclient->uploadPart($partRequest);
|
|
$this->assertEquals(200, $partResult->statusCode);
|
|
$part = new Oss\Models\UploadPart(
|
|
$i,
|
|
$partResult->etag,
|
|
);
|
|
array_push($parts, $part);
|
|
$i++;
|
|
}
|
|
fclose($file);
|
|
}
|
|
$listResult = $eclient->listParts(
|
|
new Oss\Models\ListPartsRequest(
|
|
$bucketName,
|
|
$key,
|
|
$initResult->uploadId,
|
|
)
|
|
);
|
|
$this->assertEquals(200, $listResult->statusCode);
|
|
$this->assertEquals($bucketName, $listResult->bucket);
|
|
$this->assertEquals($key, $listResult->key);
|
|
$this->assertCount(3, $listResult->parts);
|
|
|
|
$abort = $eclient->abortMultipartUpload(
|
|
new Oss\Models\AbortMultipartUploadRequest(
|
|
self::$bucketName,
|
|
$key,
|
|
$initResult->uploadId,
|
|
)
|
|
);
|
|
$this->assertEquals(204, $abort->statusCode);
|
|
} catch (\Throwable $e) {
|
|
$this->assertTrue(false, "should not here");
|
|
}
|
|
}
|
|
|
|
public function testUploader()
|
|
{
|
|
$client = $this->getDefaultClient();
|
|
$bucketName = self::$bucketName;
|
|
$key = self::randomObjectName() . '-multipart-uploader';
|
|
$masterCipher = new Oss\Crypto\MasterRsaCipher(
|
|
self::RSA_PUBLIC_KEY,
|
|
self::RSA_PRIVATE_KEY,
|
|
['key' => 'value']
|
|
);
|
|
|
|
$eclient = new Oss\EncryptionClient($client, $masterCipher);
|
|
$partSize = 200 * 1024;
|
|
$length = 500 * 1024;
|
|
$filename = self::getTempFileName();
|
|
$this->generateFile($filename, $length);
|
|
try {
|
|
$u = $eclient->newUploader();
|
|
$u->uploadFile(new \AlibabaCloud\Oss\V2\Models\PutObjectRequest(
|
|
$bucketName,
|
|
$key,
|
|
), $filename);
|
|
$getObj = $eclient->getObject(new Oss\Models\GetObjectRequest(
|
|
$bucketName,
|
|
$key,
|
|
));
|
|
$this->assertEquals(base64_encode(md5(file_get_contents($filename), true)), base64_encode(md5($getObj->body, true)));
|
|
} catch (\Throwable $e) {
|
|
$this->assertTrue(false, "should not here");
|
|
}
|
|
|
|
try {
|
|
$u = $eclient->newUploader(array(
|
|
'part_size' => $partSize,
|
|
'total_size' => $length,
|
|
));
|
|
$u->uploadFile(new \AlibabaCloud\Oss\V2\Models\PutObjectRequest(
|
|
$bucketName,
|
|
$key,
|
|
), $filename);
|
|
$getObj = $eclient->getObject(new Oss\Models\GetObjectRequest(
|
|
$bucketName,
|
|
$key,
|
|
));
|
|
$this->assertEquals(base64_encode(md5(file_get_contents($filename), true)), base64_encode(md5($getObj->body, true)));
|
|
} catch (\Throwable $e) {
|
|
$this->assertTrue(false, "should not here");
|
|
}
|
|
|
|
try {
|
|
$u = $eclient->newUploader(array(
|
|
'part_size' => $partSize,
|
|
'total_size' => $length,
|
|
));
|
|
$u->uploadFrom(new \AlibabaCloud\Oss\V2\Models\PutObjectRequest(
|
|
$bucketName,
|
|
$key,
|
|
),
|
|
new LazyOpenStream($filename, 'rb'),
|
|
[
|
|
'part_size' => $partSize,
|
|
]);
|
|
$getObj = $eclient->getObject(new Oss\Models\GetObjectRequest(
|
|
$bucketName,
|
|
$key,
|
|
));
|
|
$this->assertEquals(base64_encode(md5(file_get_contents($filename), true)), base64_encode(md5($getObj->body, true)));
|
|
} catch (\Throwable $e) {
|
|
$this->assertTrue(false, "should not here");
|
|
}
|
|
|
|
unlink($filename);
|
|
}
|
|
|
|
public function testDownloader()
|
|
{
|
|
$client = $this->getDefaultClient();
|
|
$bucketName = self::$bucketName;
|
|
$key = self::randomObjectName() . '-multipart-uploader';
|
|
$masterCipher = new Oss\Crypto\MasterRsaCipher(
|
|
self::RSA_PUBLIC_KEY,
|
|
self::RSA_PRIVATE_KEY,
|
|
);
|
|
$length = 500 * 1024;
|
|
$partSize = 200 * 1024;
|
|
$eclient = new Oss\EncryptionClient($client, $masterCipher);
|
|
$downFileName = self::getTempFileName() . "-download.tmp";
|
|
$bigFileName = self::getTempFileName() . "-bigfile.tmp";
|
|
$this->generateFile($bigFileName, $length);
|
|
$content = \file_get_contents($bigFileName);
|
|
$u = $eclient->newUploader();
|
|
$u->uploadFile(new \AlibabaCloud\Oss\V2\Models\PutObjectRequest(
|
|
$bucketName,
|
|
$key,
|
|
), $bigFileName);
|
|
|
|
try {
|
|
$d = $eclient->newDownloader();
|
|
$d->downloadFile(new Oss\Models\GetObjectRequest($bucketName, $key), $downFileName);
|
|
$this->assertEquals(md5_file($bigFileName), md5_file($downFileName));
|
|
} catch (\Throwable $e) {
|
|
$this->assertTrue(false, "should not here");
|
|
}
|
|
|
|
try {
|
|
$d = $eclient->newDownloader(
|
|
[
|
|
'part_size' => $partSize,
|
|
'parallel_num' => 1,
|
|
]
|
|
);
|
|
$d->downloadFile(new Oss\Models\GetObjectRequest($bucketName, $key), $downFileName);
|
|
$this->assertEquals(md5_file($bigFileName), md5_file($downFileName));
|
|
} catch (\Throwable $e) {
|
|
$this->assertTrue(false, "should not here");
|
|
}
|
|
|
|
try {
|
|
$d = $eclient->newDownloader(
|
|
[
|
|
'part_size' => $partSize,
|
|
'parallel_num' => 2,
|
|
]
|
|
);
|
|
$d->downloadFile(new Oss\Models\GetObjectRequest($bucketName, $key), $downFileName);
|
|
$this->assertEquals(md5_file($bigFileName), md5_file($downFileName));
|
|
} catch (\Throwable $e) {
|
|
$this->assertTrue(false, "should not here");
|
|
}
|
|
|
|
try {
|
|
$d = $eclient->newDownloader(
|
|
[
|
|
'part_size' => $partSize,
|
|
'parallel_num' => 1,
|
|
]
|
|
);
|
|
$stream = new BufferStream(1 * 1024 * 1024);
|
|
$result = $d->downloadTo(
|
|
new Oss\Models\GetObjectRequest(
|
|
$bucketName,
|
|
$key
|
|
),
|
|
$stream,
|
|
);
|
|
$gotContent = $stream->getContents();
|
|
$this->assertEquals($length, $result->written);
|
|
$this->assertEquals($length, strlen($gotContent));
|
|
$this->assertEquals($content, $gotContent);
|
|
$this->assertEquals(md5_file($bigFileName), md5_file($downFileName));
|
|
} catch (\Throwable $e) {
|
|
$this->assertTrue(false, "should not here");
|
|
}
|
|
}
|
|
|
|
public function testEncryptionCompatibility()
|
|
{
|
|
$client = $this->getDefaultClient();
|
|
$bucketName = self::$bucketName;
|
|
$key = 'example.jpg';
|
|
|
|
$filename = self::getDataPath() . DIRECTORY_SEPARATOR . 'example.jpg';
|
|
$filesize = filesize($filename);
|
|
$content = file_get_contents($filename);
|
|
|
|
$encFilename = self::getDataPath() . DIRECTORY_SEPARATOR . 'enc-example.jpg';
|
|
$encFilesize = filesize($encFilename);
|
|
$encContent = file_get_contents($encFilename);
|
|
|
|
$this->assertEquals($filesize, $encFilesize);
|
|
$this->assertNotEquals($content, $encContent);
|
|
|
|
// decrypt only
|
|
$masterCipher = new Oss\Crypto\MasterRsaCipher(
|
|
null,
|
|
self::RSA_PRIVATE_KEY,
|
|
);
|
|
|
|
$eclient = new Oss\EncryptionClient($client, $masterCipher);
|
|
|
|
// put test encrypted data
|
|
$putObjRequest = new Oss\Models\PutObjectRequest(
|
|
$bucketName,
|
|
$key,
|
|
);
|
|
$putObjRequest->body = Oss\Utils::streamFor($encContent);
|
|
$putObjRequest->metadata = [
|
|
"client-side-encryption-key" => "nyXOp7delQ/MQLjKQMhHLaT0w7u2yQoDLkSnK8MFg/MwYdh4na4/LS8LLbLcM18m8I/ObWUHU775I50sJCpdv+f4e0jLeVRRiDFWe+uo7Puc9j4xHj8YB3QlcIOFQiTxHIB6q+C+RA6lGwqqYVa+n3aV5uWhygyv1MWmESurppg=",
|
|
"client-side-encryption-start" => "De/S3T8wFjx7QPxAAFl7h7TeI2EsZlfCwox4WhLGng5DK2vNXxULmulMUUpYkdc9umqmDilgSy5Z3Foafw+v4JJThfw68T/9G2gxZLrQTbAlvFPFfPM9Ehk6cY4+8WpY32uN8w5vrHyoSZGr343NxCUGIp6fQ9sSuOLMoJg7hNw=",
|
|
"client-side-encryption-cek-alg" => "AES/CTR/NoPadding",
|
|
"client-side-encryption-wrap-alg" => "RSA/NONE/PKCS1Padding",
|
|
];
|
|
$result = $client->putObject($putObjRequest);
|
|
$this->assertEquals(200, $result->statusCode);
|
|
$this->assertEquals('OK', $result->status);
|
|
$this->assertEquals(True, count($result->headers) > 0);
|
|
$this->assertEquals(24, strlen($result->requestId));
|
|
|
|
// use non-encryption client to get object
|
|
$result = $client->getObject(new Oss\Models\GetObjectRequest($bucketName, $key));
|
|
$this->assertEquals(200, $result->statusCode);
|
|
$this->assertEquals('OK', $result->status);
|
|
$this->assertEquals(True, count($result->headers) > 0);
|
|
$this->assertEquals(24, strlen($result->requestId));
|
|
$this->assertEquals($encContent, $result->body->getContents());
|
|
|
|
// use encryption client to get object
|
|
$result = $eclient->getObject(new Oss\Models\GetObjectRequest($bucketName, $key));
|
|
$this->assertEquals(200, $result->statusCode);
|
|
$this->assertEquals('OK', $result->status);
|
|
$this->assertEquals(True, count($result->headers) > 0);
|
|
$this->assertEquals(24, strlen($result->requestId));
|
|
$this->assertEquals($content, $result->body->getContents());
|
|
$this->assertInstanceOf(GuzzleHttp\Psr7\Stream::class, $result->body);
|
|
|
|
// use encryption client to get object into filepath
|
|
$filenameSave = self::getTempFileName();
|
|
$result = $eclient->getObject(
|
|
new Oss\Models\GetObjectRequest($bucketName, $key),
|
|
[
|
|
'request_options' =>
|
|
['sink' => $filenameSave]
|
|
]
|
|
);
|
|
$this->assertEquals(200, $result->statusCode);
|
|
$this->assertEquals('OK', $result->status);
|
|
$this->assertEquals(True, count($result->headers) > 0);
|
|
$this->assertEquals(24, strlen($result->requestId));
|
|
$this->assertFileEquals($filename, $filenameSave);
|
|
$this->assertNull($result->body);
|
|
}
|
|
|
|
public function testGetObjectInvalidArgument()
|
|
{
|
|
$client = $this->getDefaultClient();
|
|
$bucketName = self::$bucketName;
|
|
$key = self::randomObjectName();
|
|
$filesize = 25 * 1024 + 123;
|
|
$filename = self::getTempFileName();
|
|
$this->generateFile($filename, $filesize);
|
|
$content = file_get_contents($filename);
|
|
|
|
$masterCipher = new Oss\Crypto\MasterRsaCipher(
|
|
self::RSA_PUBLIC_KEY,
|
|
self::RSA_PRIVATE_KEY,
|
|
);
|
|
|
|
$eclient = new Oss\EncryptionClient($client, $masterCipher);
|
|
|
|
// put object
|
|
$putObjRequest = new Oss\Models\PutObjectRequest(
|
|
$bucketName,
|
|
$key,
|
|
);
|
|
$putObjRequest->contentMd5 = base64_encode(md5_file($filename, true));
|
|
$putObjRequest->contentLength = $filesize;
|
|
$putObjRequest->body = Oss\Utils::streamFor($content);
|
|
$result = $eclient->putObject($putObjRequest);
|
|
$this->assertEquals(200, $result->statusCode);
|
|
$this->assertEquals('OK', $result->status);
|
|
$this->assertEquals(True, count($result->headers) > 0);
|
|
$this->assertEquals(24, strlen($result->requestId));
|
|
|
|
// get object
|
|
$result = $eclient->getObject(new Oss\Models\GetObjectRequest(
|
|
$bucketName,
|
|
$key
|
|
));
|
|
$this->assertEquals(200, $result->statusCode);
|
|
$this->assertEquals('OK', $result->status);
|
|
$this->assertEquals(True, count($result->headers) > 0);
|
|
$this->assertEquals(24, strlen($result->requestId));
|
|
$this->assertEquals($content, $result->body->getContents());
|
|
$this->assertEquals($filesize, $result->contentLength);
|
|
$this->assertEquals(strval($filesize), $result->headers['Content-Length']);
|
|
|
|
try {
|
|
$offset = 0;
|
|
$request = new Oss\Models\GetObjectRequest(
|
|
$bucketName,
|
|
$key
|
|
);
|
|
$request->rangeHeader = "2bytes=$offset-";
|
|
$result = $eclient->getObject($request);
|
|
$this->assertTrue(false, 'should not here');
|
|
} catch (\InvalidArgumentException $e) {
|
|
$this->assertStringContainsString('request.rangeHeader is invalid, got', $e->getMessage());
|
|
}
|
|
|
|
}
|
|
|
|
public function testInitiateMultipartUploadInvalidArgument()
|
|
{
|
|
$client = $this->getDefaultClient();
|
|
$bucketName = self::$bucketName;
|
|
$key = self::randomObjectName();
|
|
|
|
$masterCipher = new Oss\Crypto\MasterRsaCipher(
|
|
self::RSA_PUBLIC_KEY,
|
|
self::RSA_PRIVATE_KEY,
|
|
);
|
|
|
|
$eclient = new Oss\EncryptionClient($client, $masterCipher);
|
|
try {
|
|
$result = $eclient->initiateMultipartUpload(new Oss\Models\InitiateMultipartUploadRequest(
|
|
$bucketName,
|
|
$key
|
|
));
|
|
$this->assertTrue(false, 'should not here');
|
|
} catch (\InvalidArgumentException $e) {
|
|
$this->assertStringContainsString('request.csePartSize is invalid.', $e->getMessage());
|
|
}
|
|
|
|
try {
|
|
$request = new Oss\Models\InitiateMultipartUploadRequest(
|
|
$bucketName,
|
|
$key
|
|
);
|
|
$request->csePartSize = 1;
|
|
$result = $eclient->initiateMultipartUpload($request);
|
|
$this->assertTrue(false, 'should not here');
|
|
} catch (\InvalidArgumentException $e) {
|
|
$this->assertStringContainsString('request.cseDataSize is invalid.', $e->getMessage());
|
|
}
|
|
|
|
try {
|
|
$request = new Oss\Models\InitiateMultipartUploadRequest(
|
|
$bucketName,
|
|
$key
|
|
);
|
|
$request->csePartSize = 1;
|
|
$request->cseDataSize = 200;
|
|
$result = $eclient->initiateMultipartUpload($request);
|
|
$this->assertTrue(false, 'should not here');
|
|
} catch (\InvalidArgumentException $e) {
|
|
$this->assertStringContainsString('request.csePartSize must be aligned to', $e->getMessage());
|
|
}
|
|
|
|
}
|
|
|
|
public function testUploadPartInvalidArgument()
|
|
{
|
|
$client = $this->getDefaultClient();
|
|
$bucketName = self::$bucketName;
|
|
$key = self::randomObjectName() . '-multipart';
|
|
$masterCipher = new Oss\Crypto\MasterRsaCipher(
|
|
self::RSA_PUBLIC_KEY,
|
|
self::RSA_PRIVATE_KEY,
|
|
['key' => 'value']
|
|
);
|
|
|
|
$eclient = new Oss\EncryptionClient($client, $masterCipher);
|
|
$partSize = 200 * 1024;
|
|
$length = 500 * 1024;
|
|
$bigFileName = self::getTempFileName() . "-bigfile.tmp";
|
|
$this->generateFile($bigFileName, $length);
|
|
try {
|
|
$file = fopen($bigFileName, 'r');
|
|
$parts = array();
|
|
if ($file) {
|
|
$i = 1;
|
|
while (!feof($file)) {
|
|
$chunk = fread($file, $partSize);
|
|
$partRequest = new Oss\Models\UploadPartRequest(
|
|
$bucketName,
|
|
$key,
|
|
$i,
|
|
'123',
|
|
strlen($chunk),
|
|
null,
|
|
null,
|
|
null,
|
|
Oss\Utils::streamFor($chunk)
|
|
);
|
|
$partResult = $eclient->uploadPart($partRequest);
|
|
$part = new Oss\Models\UploadPart(
|
|
$i,
|
|
$partResult->etag,
|
|
);
|
|
array_push($parts, $part);
|
|
$i++;
|
|
}
|
|
fclose($file);
|
|
}
|
|
$this->assertTrue(false, "should not here");
|
|
} catch (\Throwable $e) {
|
|
$this->assertStringContainsString('request.encryptionMultiPart is null.', $e->getMessage());
|
|
}
|
|
|
|
try {
|
|
$file = fopen($bigFileName, 'r');
|
|
$parts = array();
|
|
if ($file) {
|
|
$i = 1;
|
|
while (!feof($file)) {
|
|
$chunk = fread($file, $partSize);
|
|
$partRequest = new Oss\Models\UploadPartRequest(
|
|
$bucketName,
|
|
$key,
|
|
$i,
|
|
'123',
|
|
strlen($chunk),
|
|
null,
|
|
null,
|
|
null,
|
|
Oss\Utils::streamFor($chunk)
|
|
);
|
|
$partRequest->encryptionMultipartContext = new Oss\Models\EncryptionMultipartContext();
|
|
$partResult = $eclient->uploadPart($partRequest);
|
|
$part = new Oss\Models\UploadPart(
|
|
$i,
|
|
$partResult->etag,
|
|
);
|
|
array_push($parts, $part);
|
|
$i++;
|
|
}
|
|
fclose($file);
|
|
}
|
|
$this->assertTrue(false, "should not here");
|
|
} catch (\Throwable $e) {
|
|
$this->assertStringContainsString('request.encryptionMultiPart is invalid.', $e->getMessage());
|
|
}
|
|
|
|
try {
|
|
$file = fopen($bigFileName, 'r');
|
|
$builder = new Oss\Crypto\AesCtrCipherBuilder($masterCipher);
|
|
$cc = $builder->fromCipherData();
|
|
$cc->getCipherData();
|
|
$parts = array();
|
|
if ($file) {
|
|
$i = 1;
|
|
while (!feof($file)) {
|
|
$chunk = fread($file, $partSize);
|
|
$partRequest = new Oss\Models\UploadPartRequest(
|
|
$bucketName,
|
|
$key,
|
|
$i,
|
|
'123',
|
|
strlen($chunk),
|
|
null,
|
|
null,
|
|
null,
|
|
Oss\Utils::streamFor($chunk)
|
|
);
|
|
$partRequest->encryptionMultipartContext = new Oss\Models\EncryptionMultipartContext($cc, 100, 2);
|
|
$partResult = $eclient->uploadPart($partRequest);
|
|
$part = new Oss\Models\UploadPart(
|
|
$i,
|
|
$partResult->etag,
|
|
);
|
|
array_push($parts, $part);
|
|
$i++;
|
|
}
|
|
fclose($file);
|
|
}
|
|
$this->assertTrue(false, "should not here");
|
|
} catch (\InvalidArgumentException $e) {
|
|
$this->assertStringContainsString('request.encryptionMultiPart.partSize must be aligned to', $e->getMessage());
|
|
}
|
|
}
|
|
}
|