public void PutObject_SigV4()
{
var oldS3SigV4 = AWSConfigsS3.UseSignatureVersion4;
AWSConfigsS3.UseSignatureVersion4 = true;
try
{
using (var client = new AmazonS3Client())
{
RetryUtilities.ConfigureClient(client);
PutObjectRequest request = new PutObjectRequest()
{
BucketName = bucketName,
Key = "contentBodyPut" + random.Next(),
ContentBody = "This is the content body!",
CannedACL = S3CannedACL.AuthenticatedRead
};
request.Metadata.Add("Subject", "Content-As-Object");
PutObjectResponse response = client.PutObject(request);
Console.WriteLine("S3 generated ETag: {0}", response.ETag);
Assert.IsTrue(response.ETag.Length > 0);
}
}
finally
{
AWSConfigsS3.UseSignatureVersion4 = oldS3SigV4;
}
}
public void Initialize()
{
kmsClient = new AmazonKeyManagementServiceClient(RegionEndpoint.USEast1);
s3Client = new AmazonS3Client(RegionEndpoint.USEast1);
// Create a bucket to store objects related to this test.
bucketName = GetOrCreateBucket(s3Client);
// Create a KMS key, and an S3 object with the KMSKeyID.
kmsKeyID = GetOrCreateKMSKey(s3Client, kmsClient, bucketName);
// Create an S3 object with a symmetric key used for testing.
symmetricAlgorithm = GetOrCreateSymmetricAlgorithm(s3Client, bucketName);
var encryptionMaterials = new EncryptionMaterials(symmetricAlgorithm);
var kmsEncryptionMaterials = new EncryptionMaterials(kmsKeyID);
AmazonS3CryptoConfiguration config = new AmazonS3CryptoConfiguration()
{
StorageMode = CryptoStorageMode.InstructionFile
};
s3EncryptionClientMetadataMode = new AmazonS3EncryptionClient(encryptionMaterials);
RetryUtilities.ForceConfigureClient(s3EncryptionClientMetadataMode);
s3EncryptionClientFileMode = new AmazonS3EncryptionClient(config, encryptionMaterials);
RetryUtilities.ForceConfigureClient(s3EncryptionClientFileMode);
s3EncryptionClientMetadataModeKMS = new AmazonS3EncryptionClient(kmsEncryptionMaterials);
RetryUtilities.ForceConfigureClient(s3EncryptionClientMetadataModeKMS);
s3EncryptionClientFileModeKMS = new AmazonS3EncryptionClient(config, kmsEncryptionMaterials);
RetryUtilities.ForceConfigureClient(s3EncryptionClientFileModeKMS);
}
public void DownloadDirectoryProgressTest()
{
// disable clock skew testing, this is a multithreaded test
using (RetryUtilities.DisableClockSkewCorrection())
{
var progressValidator = new DirectoryProgressValidator <DownloadDirectoryProgressArgs>();
ConfigureProgressValidator(progressValidator);
DownloadDirectory(progressValidator);
progressValidator.AssertOnCompletion();
}
}
public EncryptionTestsV2() : base(KmsKeyIdProvider.Instance)
{
kmsKeyID = _kmsKeyIdProvider.GetKmsId();
var rsa = RSA.Create();
var aes = Aes.Create();
var asymmetricEncryptionMaterials = new EncryptionMaterialsV2(rsa, AsymmetricAlgorithmType.RsaOaepSha1);
var symmetricEncryptionMaterials = new EncryptionMaterialsV2(aes, SymmetricAlgorithmType.AesGcm);
var kmsEncryptionMaterials =
new EncryptionMaterialsV2(kmsKeyID, KmsType.KmsContext, new Dictionary <string, string>());
var fileConfig = new AmazonS3CryptoConfigurationV2(SecurityProfile.V2)
{
StorageMode = CryptoStorageMode.InstructionFile
};
var metadataConfig = new AmazonS3CryptoConfigurationV2(SecurityProfile.V2)
{
StorageMode = CryptoStorageMode.ObjectMetadata
};
s3EncryptionClientMetadataModeSymmetricWrap =
new AmazonS3EncryptionClientV2(metadataConfig, symmetricEncryptionMaterials);
RetryUtilities.ForceConfigureClient(s3EncryptionClientMetadataModeSymmetricWrap);
s3EncryptionClientFileModeSymmetricWrap =
new AmazonS3EncryptionClientV2(fileConfig, symmetricEncryptionMaterials);
RetryUtilities.ForceConfigureClient(s3EncryptionClientFileModeSymmetricWrap);
s3EncryptionClientMetadataModeAsymmetricWrap =
new AmazonS3EncryptionClientV2(metadataConfig, asymmetricEncryptionMaterials);
RetryUtilities.ForceConfigureClient(s3EncryptionClientMetadataModeAsymmetricWrap);
s3EncryptionClientFileModeAsymmetricWrap =
new AmazonS3EncryptionClientV2(fileConfig, asymmetricEncryptionMaterials);
RetryUtilities.ForceConfigureClient(s3EncryptionClientFileModeAsymmetricWrap);
s3EncryptionClientMetadataModeKMS = new AmazonS3EncryptionClientV2(metadataConfig, kmsEncryptionMaterials);
RetryUtilities.ForceConfigureClient(s3EncryptionClientMetadataModeKMS);
s3EncryptionClientFileModeKMS = new AmazonS3EncryptionClientV2(fileConfig, kmsEncryptionMaterials);
RetryUtilities.ForceConfigureClient(s3EncryptionClientFileModeKMS);
using (var writer = File.CreateText(filePath))
{
writer.Write(SampleContent);
}
bucketName = S3TestUtils.CreateBucketWithWait(s3EncryptionClientFileModeSymmetricWrap);
}
private void PutStream(string destKey, int length, Stream stream)
{
PutObjectRequest request = new PutObjectRequest
{
BucketName = bucketName,
Key = destKey,
InputStream = stream,
};
request.Headers.ContentLength = length;
using (RetryUtilities.DisableClockSkewCorrection())
{
Client.PutObject(request);
}
}
public void TestSingleUploads()
{
// Test simple PutObject upload
var key = "contentBodyPut" + random.Next();
PutObjectRequest putObjectRequest = new PutObjectRequest()
{
BucketName = bucketName,
Key = key,
ContentBody = "This is the content body!",
};
SetMetadataAndHeaders(putObjectRequest);
Client.PutObject(putObjectRequest);
ValidateObjectMetadataAndHeaders(key);
using (var tu = new TransferUtility(Client))
{
// Test small TransferUtility upload
key = "transferUtilitySmall" + random.Next();
UtilityMethods.GenerateFile(tempFile, smallFileSize);
var smallRequest = new TransferUtilityUploadRequest
{
BucketName = bucketName,
Key = key,
FilePath = tempFile
};
SetMetadataAndHeaders(smallRequest);
tu.Upload(smallRequest);
ValidateObjectMetadataAndHeaders(key);
// Test large TransferUtility upload
// disable clock skew testing, this is a multithreaded operation
using (RetryUtilities.DisableClockSkewCorrection())
{
key = "transferUtilityLarge" + random.Next();
UtilityMethods.GenerateFile(tempFile, largeFileSize);
var largeRequest = new TransferUtilityUploadRequest
{
BucketName = bucketName,
Key = key,
FilePath = tempFile
};
SetMetadataAndHeaders(largeRequest);
tu.Upload(largeRequest);
ValidateObjectMetadataAndHeaders(key);
}
}
}
public void MultipartUploadProgressTest()
{
// disable clock skew testing, this is a multithreaded test
using (RetryUtilities.DisableClockSkewCorrection())
{
var fileName = UtilityMethods.GenerateName(@"MultipartUploadTest\File");
var progressValidator = new TransferProgressValidator <UploadProgressArgs>
{
ValidateProgressInterval = false,
Validate = (p) =>
{
Assert.AreEqual(p.FilePath, Path.Combine(basePath, fileName));
}
};
Upload(fileName, 20 * MEG_SIZE, progressValidator);
progressValidator.AssertOnCompletion();
}
}
public void PutObjectWithContentLength()
{
string sourceKey = "source";
string destKey = "dest";
string contents = "Sample contents";
int length = contents.Length;
Client.PutObject(new PutObjectRequest
{
BucketName = bucketName,
Key = sourceKey,
ContentBody = contents
});
// Disable clock skew testing when generating a presigned url
using (RetryUtilities.DisableClockSkewCorrection())
{
string url = Client.GetPreSignedURL(new GetPreSignedUrlRequest
{
BucketName = bucketName,
Key = sourceKey,
Expires = DateTime.Now + TimeSpan.FromHours(2)
});
HttpWebRequest httpRequest = HttpWebRequest.Create(url) as HttpWebRequest;
using (HttpWebResponse httpResponse = httpRequest.GetResponse() as HttpWebResponse)
using (Stream stream = httpResponse.GetResponseStream())
{
PutStream(destKey, length, stream);
}
string finalContents = GetContents(destKey);
Assert.AreEqual(contents, finalContents);
length -= 2;
httpRequest = HttpWebRequest.Create(url) as HttpWebRequest;
using (HttpWebResponse httpResponse = httpRequest.GetResponse() as HttpWebResponse)
using (Stream stream = httpResponse.GetResponseStream())
{
PutStream(destKey, length, stream);
}
finalContents = GetContents(destKey);
Assert.AreEqual(contents.Substring(0, length), finalContents);
}
}
public static void Initialize(TestContext a)
{
s3EncryptionClientMetadataMode = new AmazonS3EncryptionClient(encryptionMaterials);
RetryUtilities.ForceConfigureClient(s3EncryptionClientMetadataMode);
AmazonS3CryptoConfiguration config = new AmazonS3CryptoConfiguration()
{
StorageMode = CryptoStorageMode.InstructionFile
};
s3EncryptionClientFileMode = new AmazonS3EncryptionClient(config, encryptionMaterials);
RetryUtilities.ForceConfigureClient(s3EncryptionClientFileMode);
using (StreamWriter writer = File.CreateText(fileName))
{
writer.Write(sampleContent);
}
bucketName = S3TestUtils.CreateBucket(s3EncryptionClientFileMode);
}
public static void Initialize(TestContext a)
{
using (var kmsClient = new AmazonKeyManagementServiceClient())
{
var response = kmsClient.CreateKey(new CreateKeyRequest
{
Description = "Key for .NET integration tests.",
Origin = OriginType.AWS_KMS,
KeyUsage = KeyUsageType.ENCRYPT_DECRYPT
});
kmsKeyID = response.KeyMetadata.KeyId;
}
var encryptionMaterials = new EncryptionMaterials(RSA.Create());
var kmsEncryptionMaterials = new EncryptionMaterials(kmsKeyID);
AmazonS3CryptoConfiguration config = new AmazonS3CryptoConfiguration()
{
StorageMode = CryptoStorageMode.InstructionFile
};
s3EncryptionClientMetadataMode = new AmazonS3EncryptionClient(encryptionMaterials);
RetryUtilities.ForceConfigureClient(s3EncryptionClientMetadataMode);
s3EncryptionClientFileMode = new AmazonS3EncryptionClient(config, encryptionMaterials);
RetryUtilities.ForceConfigureClient(s3EncryptionClientFileMode);
s3EncryptionClientMetadataModeKMS = new AmazonS3EncryptionClient(kmsEncryptionMaterials);
RetryUtilities.ForceConfigureClient(s3EncryptionClientMetadataModeKMS);
s3EncryptionClientFileModeKMS = new AmazonS3EncryptionClient(config, kmsEncryptionMaterials);
RetryUtilities.ForceConfigureClient(s3EncryptionClientFileModeKMS);
using (StreamWriter writer = File.CreateText(filePath))
{
writer.Write(sampleContent);
}
bucketName = S3TestUtils.CreateBucket(s3EncryptionClientFileMode);
}
#pragma warning restore 0618
public EncryptionTestsV1InteropV1N() : base(KmsKeyIdProvider.Instance)
{
filePath = Path.Combine(Path.GetTempPath(), $"EncryptionPutObjectFile-{Guid.NewGuid()}.txt");
kmsKeyID = _kmsKeyIdProvider.GetKmsId();
var rsa = RSA.Create();
var aes = Aes.Create();
var asymmetricEncryptionMaterialsV1 = new Amazon.S3.Encryption.EncryptionMaterials(rsa);
var asymmetricEncryptionMaterialsV1N = new EncryptionMaterials(rsa);
var symmetricEncryptionMaterialsV1 = new Amazon.S3.Encryption.EncryptionMaterials(aes);
var symmetricEncryptionMaterialsV1N = new EncryptionMaterials(aes);
var kmsEncryptionMaterialsV1 = new Amazon.S3.Encryption.EncryptionMaterials(kmsKeyID);
var kmsEncryptionMaterialsV1N = new EncryptionMaterials(kmsKeyID);
var configV1 = new Amazon.S3.Encryption.AmazonS3CryptoConfiguration()
{
StorageMode = Amazon.S3.Encryption.CryptoStorageMode.InstructionFile
};
var configV1N = new AmazonS3CryptoConfiguration()
{
StorageMode = CryptoStorageMode.InstructionFile
};
s3EncryptionClientMetadataModeAsymmetricWrapV1 =
new Amazon.S3.Encryption.AmazonS3EncryptionClient(asymmetricEncryptionMaterialsV1);
RetryUtilities.ForceConfigureClient(s3EncryptionClientMetadataModeAsymmetricWrapV1);
s3EncryptionClientFileModeAsymmetricWrapV1 =
new Amazon.S3.Encryption.AmazonS3EncryptionClient(configV1, asymmetricEncryptionMaterialsV1);
RetryUtilities.ForceConfigureClient(s3EncryptionClientFileModeAsymmetricWrapV1);
s3EncryptionClientMetadataModeSymmetricWrapV1 =
new Amazon.S3.Encryption.AmazonS3EncryptionClient(symmetricEncryptionMaterialsV1);
RetryUtilities.ForceConfigureClient(s3EncryptionClientMetadataModeSymmetricWrapV1);
s3EncryptionClientFileModeSymmetricWrapV1 =
new Amazon.S3.Encryption.AmazonS3EncryptionClient(configV1, symmetricEncryptionMaterialsV1);
RetryUtilities.ForceConfigureClient(s3EncryptionClientFileModeSymmetricWrapV1);
s3EncryptionClientMetadataModeKMSV1 =
new Amazon.S3.Encryption.AmazonS3EncryptionClient(kmsEncryptionMaterialsV1);
RetryUtilities.ForceConfigureClient(s3EncryptionClientMetadataModeKMSV1);
s3EncryptionClientFileModeKMSV1 =
new Amazon.S3.Encryption.AmazonS3EncryptionClient(configV1, kmsEncryptionMaterialsV1);
RetryUtilities.ForceConfigureClient(s3EncryptionClientFileModeKMSV1);
s3EncryptionClientMetadataModeAsymmetricWrapV1N =
new AmazonS3EncryptionClient(asymmetricEncryptionMaterialsV1N);
RetryUtilities.ForceConfigureClient(s3EncryptionClientMetadataModeAsymmetricWrapV1N);
s3EncryptionClientFileModeAsymmetricWrapV1N =
new AmazonS3EncryptionClient(configV1N, asymmetricEncryptionMaterialsV1N);
RetryUtilities.ForceConfigureClient(s3EncryptionClientFileModeAsymmetricWrapV1N);
s3EncryptionClientMetadataModeSymmetricWrapV1N =
new AmazonS3EncryptionClient(symmetricEncryptionMaterialsV1N);
RetryUtilities.ForceConfigureClient(s3EncryptionClientMetadataModeSymmetricWrapV1N);
s3EncryptionClientFileModeSymmetricWrapV1N =
new AmazonS3EncryptionClient(configV1N, symmetricEncryptionMaterialsV1N);
RetryUtilities.ForceConfigureClient(s3EncryptionClientFileModeSymmetricWrapV1N);
s3EncryptionClientMetadataModeKMSV1N = new AmazonS3EncryptionClient(kmsEncryptionMaterialsV1N);
RetryUtilities.ForceConfigureClient(s3EncryptionClientMetadataModeKMSV1N);
s3EncryptionClientFileModeKMSV1N = new AmazonS3EncryptionClient(configV1N, kmsEncryptionMaterialsV1N);
RetryUtilities.ForceConfigureClient(s3EncryptionClientFileModeKMSV1N);
using (var writer = File.CreateText(filePath))
{
writer.Write(SampleContent);
}
bucketName = S3TestUtils.CreateBucketWithWait(s3EncryptionClientFileModeAsymmetricWrapV1);
}
public void TestSingleUploadWithSpacesInMetadata()
{
string metadataName = "document";
string metadataValue = " A B C ";
// Test simple PutObject upload
var key = "contentBodyPut" + random.Next();
PutObjectRequest putObjectRequest = new PutObjectRequest()
{
BucketName = bucketName,
Key = key,
ContentBody = "This is the content body!",
};
putObjectRequest.Metadata[metadataName] = metadataValue;
Client.PutObject(putObjectRequest);
using (var response = Client.GetObject(bucketName, key)) // Validate metadata
{
Assert.AreEqual(metadataValue.Trim(), response.Metadata[metadataName]);
}
using (var tu = new TransferUtility(Client))
{
// Test small TransferUtility upload
key = "transferUtilitySmall" + random.Next();
UtilityMethods.GenerateFile(tempFile, smallFileSize);
var smallRequest = new TransferUtilityUploadRequest
{
BucketName = bucketName,
Key = key,
FilePath = tempFile
};
smallRequest.Metadata[metadataName] = metadataValue;
tu.Upload(smallRequest);
using (var response = Client.GetObject(bucketName, key)) // Validate metadata
{
Assert.AreEqual(metadataValue.Trim(), response.Metadata[metadataName]);
}
// Test large TransferUtility upload
// disable clock skew testing, this is a multithreaded operation
using (RetryUtilities.DisableClockSkewCorrection())
{
key = "transferUtilityLarge" + random.Next();
UtilityMethods.GenerateFile(tempFile, largeFileSize);
var largeRequest = new TransferUtilityUploadRequest
{
BucketName = bucketName,
Key = key,
FilePath = tempFile
};
largeRequest.Metadata[metadataName] = metadataValue;
tu.Upload(largeRequest);
using (var response = Client.GetObject(bucketName, key)) // Validate metadata
{
Assert.AreEqual(metadataValue.Trim(), response.Metadata[metadataName]);
}
}
}
}
