//[TestMethod()]
public void TestEnDecryption()
{
PlainFileKey generatedFK = Crypto.GenerateFileKey();
byte[] plainFileBytes = Encoding.UTF8.GetBytes("Dinge die ich jetzt testen will.");
// Encrypt text
PlainDataContainer plainDC = new PlainDataContainer(plainFileBytes);
FileEncryptionCipher encCipher = Crypto.CreateFileEncryptionCipher(generatedFK);
EncryptedDataContainer encryptedResult;
using (MemoryStream ms = new MemoryStream()) {
EncryptedDataContainer encryptedDC = encCipher.ProcessBytes(plainDC);
ms.Write(encryptedDC.Content, 0, encryptedDC.Content.Length);
encryptedDC = encCipher.DoFinal();
ms.Write(encryptedDC.Content, 0, encryptedDC.Content.Length);
encryptedResult = new EncryptedDataContainer(ms.ToArray(), encryptedDC.Tag);
}
generatedFK.Tag = Convert.ToBase64String(encryptedResult.Tag);
// Decrypt text
FileDecryptionCipher decCipher = Crypto.CreateFileDecryptionCipher(generatedFK);
PlainDataContainer decryptedResult;
using (MemoryStream ms = new MemoryStream()) {
PlainDataContainer decryptedDC = decCipher.ProcessBytes(new EncryptedDataContainer(encryptedResult.Content, null));
ms.Write(decryptedDC.Content, 0, decryptedDC.Content.Length);
decryptedDC = decCipher.DoFinal(new EncryptedDataContainer(null, Convert.FromBase64String(generatedFK.Tag)));
ms.Write(decryptedDC.Content, 0, decryptedDC.Content.Length);
decryptedResult = new PlainDataContainer(ms.ToArray());
}
System.Diagnostics.Debug.WriteLine("Result: " + Encoding.UTF8.GetString(decryptedResult.Content));
}
public void TestEncryptMultiBlock_Success()
{
PlainFileKey pfk = TestUtilities.ReadTestResource <PlainFileKey>(TestResources.plain_file_key);
byte[] ft = Convert.FromBase64String(pfk.Tag);
byte[] pfc = Convert.FromBase64String(TestResources.plain_file);
byte[] efc = Convert.FromBase64String(TestResources.enc_file);
FileEncryptionCipher encCipher = Crypto.CreateFileEncryptionCipher(pfk);
using (MemoryStream output = new MemoryStream()) {
using (MemoryStream input = new MemoryStream(pfc)) {
byte[] buffer = new byte[16];
int bytesRead;
while ((bytesRead = input.Read(buffer, 0, buffer.Length)) != 0)
{
byte[] blockBytes = new byte[bytesRead];
Array.Copy(buffer, blockBytes, bytesRead);
EncryptedDataContainer currentEdc = encCipher.ProcessBytes(new PlainDataContainer(blockBytes));
output.Write(currentEdc.Content, 0, currentEdc.Content.Length);
}
}
EncryptedDataContainer testEdc = encCipher.DoFinal();
output.Write(testEdc.Content, 0, testEdc.Content.Length);
byte[] testFt = testEdc.Tag;
byte[] testEfc = output.ToArray();
CollectionAssert.AreEqual(efc, testEfc, "File content does not match!");
CollectionAssert.AreEqual(ft, testFt, "File tag does not match!");
}
}
private void TestEncryptProcessArguments(PlainDataContainer pdc)
{
PlainFileKey pfk = TestUtilities.ReadTestResource <PlainFileKey>(TestResources.plain_file_key);
FileEncryptionCipher encCipher = Crypto.CreateFileEncryptionCipher(pfk);
encCipher.ProcessBytes(pdc);
}
public void Encrypted_RunSync_IOException()
{
// ARRANGE
byte[] fileMock = new byte[1888];
new Random().NextBytes(fileMock);
Stream s = new MemoryStream(fileMock);
IInternalDracoonClient c = FactoryClients.InternalDracoonClientMock(true);
FileUploadCallbackMock callback = new FileUploadCallbackMock();
ApiCreateFileUpload acfu = FactoryFile.ApiCreateFileUpload;
acfu.Classification = null;
EncFileUpload f = new EncFileUpload(c, "id1", FactoryFile.UploadFileRequest, s, FactoryUser.UserPublicKey, fileMock.Length);
f.AddFileUploadCallback(callback);
Mock.Arrange(() => FileMapper.ToApiCreateFileUpload(Arg.IsAny <FileUploadRequest>())).Returns(acfu);
Mock.Arrange(() => c.Builder.PostCreateFileUpload(Arg.IsAny <ApiCreateFileUpload>())).Returns(FactoryRestSharp.PostCreateFileUploadMock());
Mock.Arrange(() => c.Executor.DoSyncApiCall <ApiUploadToken>(Arg.IsAny <IRestRequest>(), RequestType.PostUploadToken, 0))
.Returns(FactoryFile.ApiUploadToken);
Mock.Arrange(() => c.Builder.GetGeneralSettings())
.Returns(FactoryRestSharp.RestRequestWithAuth(ApiConfig.ApiGetGeneralConfig, Method.GET)).Occurs(1);
Mock.Arrange(() => c.Executor.DoSyncApiCall <ApiGeneralSettings>(Arg.IsAny <IRestRequest>(), RequestType.GetGeneralSettings, 0))
.Returns(FactoryServerSettings.ApiGeneralSettings).Occurs(1);
Mock.Arrange(() => Crypto.Sdk.Crypto.GenerateFileKey(Arg.AnyString)).Returns(FactoryFile.PlainFileKey);
FileEncryptionCipher cipher = Mock.Create <FileEncryptionCipher>();
Mock.Arrange(() => Crypto.Sdk.Crypto.CreateFileEncryptionCipher(Arg.IsAny <PlainFileKey>())).Returns(cipher);
Mock.Arrange(() => cipher.ProcessBytes(Arg.IsAny <PlainDataContainer>())).Returns(new EncryptedDataContainer(fileMock, fileMock));
Mock.Arrange(() => cipher.DoFinal()).Returns(new EncryptedDataContainer(fileMock, fileMock));
Mock.NonPublic.Arrange <ApiUploadChunkResult>(f, "UploadChunkWebClient", ArgExpr.IsAny <Uri>(), ArgExpr.IsAny <byte[]>(),
ArgExpr.IsAny <long>(), ArgExpr.IsAny <int>()).Throws(new IOException());
// ACT - ASSERT
Assert.Throws <DracoonFileIOException>(() => f.RunSync());
s.Close();
}
private EncryptedDataContainer EncryptChunk(FileEncryptionCipher cipher, int byteCount, byte[] chunk, bool isFinalBlock)
{
if (isFinalBlock)
{
return(cipher.DoFinal());
}
byte[] plainChunkBytes = new byte[byteCount];
Buffer.BlockCopy(chunk, 0, plainChunkBytes, 0, byteCount);
return(cipher.ProcessBytes(new PlainDataContainer(plainChunkBytes)));
}
private EncryptedDataContainer TestEncryptSingleBlock(PlainFileKey pfk, PlainDataContainer pdc)
{
FileEncryptionCipher encCipher = Crypto.CreateFileEncryptionCipher(pfk);
using (MemoryStream output = new MemoryStream()) {
EncryptedDataContainer currentEdc = encCipher.ProcessBytes(pdc);
output.Write(currentEdc.Content, 0, currentEdc.Content.Length);
currentEdc = encCipher.DoFinal();
output.Write(currentEdc.Content, 0, currentEdc.Content.Length);
return(new EncryptedDataContainer(output.ToArray(), currentEdc.Tag));
}
}
/// <summary>
/// Encrypts some bytes.
/// </summary>
/// <param name="fileKey">The file key to use.</param>
/// <param name="data">The plain bytes.</param>
/// <returns>Encrypted bytes.</returns>
private static byte[] EncryptData(PlainFileKey fileKey, byte[] data)
{
// !!! This method is an example for encryption. It uses byte array streams for input and
// output. However, any kind of stream (e.g. FileInputStream) could be used here.
FileEncryptionCipher cipher = Crypto.CreateFileEncryptionCipher(fileKey);
byte[] encData;
using (Stream is2 = new MemoryStream(data))
{
using (MemoryStream os = new MemoryStream())
{
byte[] buffer = new byte[BLOCK_SIZE];
int count;
try
{
EncryptedDataContainer eDataContainer;
// Encrypt blocks
while ((count = is2.Read(buffer, 0, buffer.Length)) > 0)
{
byte[] pData = createByteArray(buffer, count);
eDataContainer = cipher.ProcessBytes(new PlainDataContainer(pData));
os.Write(eDataContainer.Content, 0, eDataContainer.Content.Length);
}
// Complete encryption
eDataContainer = cipher.DoFinal();
os.Write(eDataContainer.Content, 0, eDataContainer.Content.Length);
String tag = Convert.ToBase64String(eDataContainer.Tag);
fileKey.Tag = tag;
encData = os.ToArray();
}
catch (IOException e)
{
throw new Exception("Error while reading/writing data!", e);
}
catch (CryptoException e)
{
throw new Exception("Error while encrypting data!", e);
}
}
}
return(encData);
}
public void Encrypted_RunSync_S3_KnownFileSize_Success()
{
// ARRANGE
byte[] fileMock = new byte[1564];
new Random().NextBytes(fileMock);
Stream s = new MemoryStream(fileMock);
IInternalDracoonClient c = FactoryClients.InternalDracoonClientMock(true);
FileUploadCallbackMock callback = new FileUploadCallbackMock();
EncFileUpload f = new EncFileUpload(c, "id1", FactoryFile.UploadFileRequest, s, FactoryUser.UserPublicKey, fileMock.Length);
f.AddFileUploadCallback(callback);
ApiGeneralSettings generalSettings = FactoryServerSettings.ApiGeneralSettings;
generalSettings.UseS3Storage = true;
ApiCreateFileUpload acfu = FactoryFile.ApiCreateFileUpload;
acfu.Classification = null;
Mock.Arrange(() => c.Builder.PostCreateFileUpload(Arg.IsAny <ApiCreateFileUpload>())).Returns(FactoryRestSharp.PostCreateFileUploadMock())
.Occurs(1);
Mock.Arrange(() => c.Executor.DoSyncApiCall <ApiUploadToken>(Arg.IsAny <IRestRequest>(), RequestType.PostUploadToken, 0))
.Returns(FactoryFile.ApiUploadToken).Occurs(1);
Mock.Arrange(() => c.Builder.PutCompleteS3FileUpload(Arg.AnyString, Arg.IsAny <ApiCompleteFileUpload>()))
.Returns(FactoryRestSharp.PutCompleteFileUploadMock("path")).Occurs(1);
Mock.Arrange(() => c.Executor.DoSyncApiCall <VoidResponse>(Arg.IsAny <IRestRequest>(), RequestType.PutCompleteS3Upload, 0)).DoNothing()
.Occurs(1);
Mock.Arrange(() => c.Builder.GetGeneralSettings())
.Returns(FactoryRestSharp.RestRequestWithAuth(ApiConfig.ApiGetGeneralConfig, Method.GET)).Occurs(1);
Mock.Arrange(() => c.Executor.DoSyncApiCall <ApiGeneralSettings>(Arg.IsAny <IRestRequest>(), RequestType.GetGeneralSettings, 0))
.Returns(generalSettings).Occurs(1);
Mock.Arrange(() => c.Builder.PostGetS3Urls(Arg.AnyString, Arg.IsAny <ApiGetS3Urls>())).Returns(FactoryRestSharp.PostGetS3UrlsMock())
.OccursAtLeast(1);
Mock.Arrange(() => c.Executor.DoSyncApiCall <ApiS3Urls>(Arg.IsAny <IRestRequest>(), RequestType.PostGetS3Urls, 0))
.Returns(FactoryFile.ApiS3Urls).OccursAtLeast(1);
Mock.Arrange(() => c.Builder.GetS3Status(Arg.AnyString)).Returns(FactoryRestSharp.GetS3StatusMock).OccursAtLeast(1);
Mock.Arrange(() => c.Executor.DoSyncApiCall <ApiS3Status>(Arg.IsAny <IRestRequest>(), RequestType.GetS3Status, 0))
.Returns(FactoryFile.ApiS3Status).OccursAtLeast(1);
Mock.Arrange(() => FileMapper.ToApiCreateFileUpload(Arg.IsAny <FileUploadRequest>())).Returns(acfu).Occurs(1);
Mock.Arrange(() => NodeMapper.FromApiNode(Arg.IsAny <ApiNode>())).Returns(FactoryNode.Node).Occurs(1);
Mock.Arrange(() => FileMapper.ToApiCompleteFileUpload(Arg.IsAny <FileUploadRequest>())).Returns(FactoryFile.ApiCompleteFileUpload);
DracoonWebClientExtension wc = Mock.Create <DracoonWebClientExtension>();
Mock.Arrange(() => Mock.Create <UploadProgressChangedEventArgs>().BytesSent).IgnoreInstance();
Mock.Arrange(() => c.Executor.ExecuteWebClientChunkUpload(Arg.IsAny <WebClient>(), Arg.IsAny <Uri>(), Arg.IsAny <byte[]>(),
RequestType.PutUploadS3Chunk, Arg.IsAny <Thread>(), Arg.AnyInt)).DoInstead(() => Thread.Sleep(250))
.Raises(() => wc.UploadProgressChanged += null, null, Mock.Create <UploadProgressChangedEventArgs>()).Returns(new byte[13]);
Mock.Arrange(() => c.Builder.ProvideS3ChunkUploadWebClient()).Returns(wc);
Mock.Arrange(() => JsonConvert.DeserializeObject <ApiUploadChunkResult>(Arg.AnyString)).Returns(FactoryFile.ApiUploadChunkResult);
Mock.Arrange(() => Crypto.Sdk.Crypto.GenerateFileKey(Arg.AnyString)).Returns(FactoryFile.PlainFileKey).Occurs(1);
FileEncryptionCipher cipher = Mock.Create <FileEncryptionCipher>();
Mock.Arrange(() => Crypto.Sdk.Crypto.CreateFileEncryptionCipher(Arg.IsAny <PlainFileKey>())).Returns(cipher).Occurs(1);
Mock.Arrange(() => cipher.ProcessBytes(Arg.IsAny <PlainDataContainer>())).Returns(new EncryptedDataContainer(fileMock, fileMock))
.OccursAtLeast(1);
Mock.Arrange(() => cipher.DoFinal()).Returns(new EncryptedDataContainer(fileMock, fileMock)).OccursAtLeast(1);
Mock.Arrange(() => Crypto.Sdk.Crypto.EncryptFileKey(Arg.IsAny <PlainFileKey>(), Arg.IsAny <UserPublicKey>()))
.Returns(FactoryFile.EncryptedFileKey).Occurs(1);
Mock.Arrange(() => FileMapper.ToApiFileKey(Arg.IsAny <EncryptedFileKey>())).Returns(FactoryFile.ApiFileKey);
Mock.Arrange(() => callback.OnStarted(Arg.AnyString)).Occurs(1);
Mock.Arrange(() => callback.OnRunning(Arg.AnyString, Arg.AnyLong, Arg.AnyLong)).OccursAtLeast(1);
Mock.Arrange(() => callback.OnFinished(Arg.AnyString, Arg.IsAny <Node>())).Occurs(1);
// ACT
Node actual = f.RunSync();
s.Close();
// ASSERT
Assert.Equal(FactoryNode.Node, actual, new NodeComparer());
Mock.Assert(callback);
Mock.Assert(c.Builder);
Mock.Assert(c.Executor);
}
public void Encrypted_RunSync_KnownFileSize_Success()
{
// ARRANGE
byte[] fileMock = new byte[1888];
new Random().NextBytes(fileMock);
Stream s = new MemoryStream(fileMock);
IInternalDracoonClient c = FactoryClients.InternalDracoonClientMock(true);
FileUploadCallbackMock callback = new FileUploadCallbackMock();
ApiCreateFileUpload acfu = FactoryFile.ApiCreateFileUpload;
acfu.Classification = null;
EncFileUpload f = new EncFileUpload(c, "id1", FactoryFile.UploadFileRequest, s, FactoryUser.UserPublicKey, fileMock.Length);
f.AddFileUploadCallback(callback);
Mock.Arrange(() => FileMapper.ToApiCreateFileUpload(Arg.IsAny <FileUploadRequest>())).Returns(acfu).Occurs(1);
Mock.Arrange(() => c.Builder.PostCreateFileUpload(Arg.IsAny <ApiCreateFileUpload>())).Returns(FactoryRestSharp.PostCreateFileUploadMock())
.Occurs(1);
Mock.Arrange(() => c.Executor.DoSyncApiCall <ApiUploadToken>(Arg.IsAny <IRestRequest>(), RequestType.PostUploadToken, 0))
.Returns(FactoryFile.ApiUploadToken).Occurs(1);
Mock.Arrange(() => c.Builder.GetGeneralSettings())
.Returns(FactoryRestSharp.RestRequestWithAuth(ApiConfig.ApiGetGeneralConfig, Method.GET)).Occurs(1);
Mock.Arrange(() => c.Executor.DoSyncApiCall <ApiGeneralSettings>(Arg.IsAny <IRestRequest>(), RequestType.GetGeneralSettings, 0))
.Returns(FactoryServerSettings.ApiGeneralSettings).Occurs(1);
Mock.Arrange(() => Crypto.Sdk.Crypto.GenerateFileKey(Arg.AnyString)).Returns(FactoryFile.PlainFileKey).Occurs(1);
FileEncryptionCipher cipher = Mock.Create <FileEncryptionCipher>();
Mock.Arrange(() => Crypto.Sdk.Crypto.CreateFileEncryptionCipher(Arg.IsAny <PlainFileKey>())).Returns(cipher).Occurs(1);
Mock.Arrange(() => cipher.ProcessBytes(Arg.IsAny <PlainDataContainer>())).Returns(new EncryptedDataContainer(fileMock, fileMock))
.OccursAtLeast(1);
Mock.Arrange(() => cipher.DoFinal()).Returns(new EncryptedDataContainer(fileMock, fileMock)).OccursAtLeast(1);
Mock.NonPublic.Arrange <ApiUploadChunkResult>(f, "UploadChunkWebClient", ArgExpr.IsAny <Uri>(), ArgExpr.IsAny <byte[]>(),
ArgExpr.IsAny <long>(), ArgExpr.IsAny <int>()).Returns(FactoryFile.ApiUploadChunkResult).OccursAtLeast(1);
Mock.Arrange(() => FileHash.CompareFileHashes(Arg.AnyString, Arg.IsAny <byte[]>(), Arg.AnyInt)).Returns(true).OccursAtLeast(1);
Mock.Arrange(() => Crypto.Sdk.Crypto.EncryptFileKey(Arg.IsAny <PlainFileKey>(), Arg.IsAny <UserPublicKey>()))
.Returns(FactoryFile.EncryptedFileKey).Occurs(1);
Mock.Arrange(() => FileMapper.ToApiCompleteFileUpload(Arg.IsAny <FileUploadRequest>())).Returns(FactoryFile.ApiCompleteFileUpload)
.Occurs(1);
Mock.Arrange(() => FileMapper.ToApiFileKey(Arg.IsAny <EncryptedFileKey>())).Returns(FactoryFile.ApiFileKey);
Mock.Arrange(() => c.Builder.PutCompleteFileUpload(Arg.AnyString, Arg.IsAny <ApiCompleteFileUpload>()))
.Returns(FactoryRestSharp.PutCompleteFileUploadMock("path")).Occurs(1);
Mock.Arrange(() => c.Executor.DoSyncApiCall <ApiNode>(Arg.IsAny <IRestRequest>(), RequestType.PutCompleteUpload, 0))
.Returns(FactoryNode.ApiNode).Occurs(1);
Mock.Arrange(() => NodeMapper.FromApiNode(Arg.IsAny <ApiNode>())).Returns(FactoryNode.Node).Occurs(1);
Mock.Arrange(() => callback.OnStarted(Arg.AnyString)).Occurs(1);
Mock.Arrange(() => callback.OnRunning(Arg.AnyString, Arg.AnyLong, Arg.AnyLong)).OccursAtLeast(1);
Mock.Arrange(() => callback.OnFinished(Arg.AnyString, Arg.IsAny <Node>())).Occurs(1);
// ACT
Node actual = f.RunSync();
s.Close();
// ASSERT
Assert.Equal(FactoryNode.Node, actual, new NodeComparer());
Mock.Assert(() => FileMapper.ToApiCreateFileUpload(Arg.IsAny <FileUploadRequest>()));
Mock.Assert(() => Crypto.Sdk.Crypto.GenerateFileKey(Arg.AnyString));
Mock.Assert(() => Crypto.Sdk.Crypto.CreateFileEncryptionCipher(Arg.IsAny <PlainFileKey>()));
Mock.Assert(() => FileHash.CompareFileHashes(Arg.AnyString, Arg.IsAny <byte[]>(), Arg.AnyInt));
Mock.Assert(() => Crypto.Sdk.Crypto.EncryptFileKey(Arg.IsAny <PlainFileKey>(), Arg.IsAny <UserPublicKey>()));
Mock.Assert(() => FileMapper.ToApiCompleteFileUpload(Arg.IsAny <FileUploadRequest>()));
Mock.Assert(() => FileMapper.ToApiFileKey(Arg.IsAny <EncryptedFileKey>()));
Mock.Assert(() => NodeMapper.FromApiNode(Arg.IsAny <ApiNode>()));
Mock.Assert(callback);
Mock.Assert(cipher);
Mock.Assert(c.Builder);
Mock.Assert(c.Executor);
Mock.Assert(c.NodesImpl);
}
private string ProcessEncryptedChunk(Uri uploadUrl, EncryptedDataContainer encryptedContainer, long uploadedByteCount, FileEncryptionCipher cipher,
bool isFinalBlock, int sendTry = 1)
{
ApiUploadChunkResult chunkResult =
UploadChunkWebClient(uploadUrl, encryptedContainer.Content, uploadedByteCount, encryptedContainer.Content.Length);
if (!FileHash.CompareFileHashes(chunkResult.Hash, encryptedContainer.Content, encryptedContainer.Content.Length))
{
if (sendTry <= 3)
{
return(ProcessEncryptedChunk(uploadUrl, encryptedContainer, uploadedByteCount, cipher, isFinalBlock, sendTry + 1));
}
else
{
throw new DracoonNetIOException("The uploaded chunk hash and local chunk hash are not equal!");
}
}
return(isFinalBlock ? Convert.ToBase64String(encryptedContainer.Tag) : null);
}
