public void TestSimpleDownload()
{
byte[] src = new byte[ushort.MaxValue];
MemoryStream dest = new MemoryStream();
new Random().NextBytes(src);
SecureTransfer.Server server = new SecureTransfer.Server(ServerKey, ClientKey.PublicKey, new RegistryStorage());
server.MaxOutboundFileChunk = 1000;
server.DownloadBytes +=
(o, e) =>
{
using (MemoryStream ms = new MemoryStream(e.ReadLength))
{
ms.Write(src, (int)e.ReadOffset, e.ReadLength);
e.SetBytes(src.Length, ms.ToArray());
}
};
SecureTransfer.Client client = new SecureTransfer.Client(ClientKey, ServerKey.PublicKey,
(id, name, stream) => server.Receive(stream));
client.Download("bla", dest);
Assert.AreEqual(Hash.SHA256(src), Hash.SHA256(dest.ToArray()));
}
public void TestDownloadOneChunk()
{
byte[] src = new byte[1024];
MemoryStream dest = new MemoryStream();
new Random().NextBytes(src);
Hash expectHash = Hash.SHA256(src);
SecureTransfer.Server server = new SecureTransfer.Server(ServerKey, ClientKey.PublicKey, new RegistryStorage());
server.MaxOutboundFileChunk = src.Length;
server.DownloadBytes +=
(o, e) =>
{
if (e.ReadLength == 0)
{
e.SetBytes(src.Length, null);
}
else
{
e.SetBytes(src.Length, src);
src = null;
}
};
SecureTransfer.Client client = new SecureTransfer.Client(ClientKey, ServerKey.PublicKey,
(id, name, stream) => server.Receive(stream));
client.Download("bla", dest);
Assert.IsNull(src);
Assert.AreEqual(expectHash, Hash.SHA256(dest.ToArray()));
}
public IContentResponse GetResponse(string method, string rawUrl, NameValueCollection headers, Stream inputStream)
{
if (StringComparer.Ordinal.Equals(rawUrl, PathSetPassword))
{
return(HandlePasswordSet(headers, inputStream));
}
if (!StringComparer.Ordinal.Equals(rawUrl, _publishUri))
{
throw new ApplicationException("Unexpected path " + rawUrl);
}
try
{
SecureTransfer.Server handler = new SecureTransfer.Server(
_content.KeyPair.ServerPrivateKey,
_content.KeyPair.ClientPublicKey,
new RegistryStorage(Path.Combine(Settings.RegistryPath, "Transfers")));
handler.BeginTransfer += BeginTransfer;
handler.BytesReceived += BytesReceived;
handler.CompleteTransfer += CompleteTransfer;
handler.ErrorRaised += ErrorRaised;
using (Stream response = handler.Receive(inputStream))
{
return(new DynamicResponse("application/binary", IOStream.ReadAllBytes(response)));
}
}
catch (Exception error)
{
Log.Error(error);
return(HttpErrorHandler.Unauthorized.GetResponse(method, rawUrl, headers, inputStream));
}
}
public void TestSimpleUpload()
{
byte[] src = new byte[ushort.MaxValue];
byte[] work = null;
byte[] dest = null;
new Random().NextBytes(src);
Hash hashSent = null;
Guid transfer = Guid.Empty;
SecureTransfer.Server server = new SecureTransfer.Server(ServerKey, ClientKey.PublicKey, new RegistryStorage());
server.MaxInboundFileChunk = 1000;
server.BeginTransfer += (o, e) => { work = new byte[e.TotalSize]; transfer = e.TransferId; };
server.CompleteTransfer += (o, e) => { dest = work; hashSent = e.ContentHash; };
server.BytesReceived +=
(o, e) =>
{
Assert.AreEqual(transfer, e.TransferId);
Assert.AreEqual(src.Length, e.TotalSize);
Assert.AreEqual("bla", e.Location);
Array.Copy(e.BytesReceived, 0, work, e.WriteOffset, e.BytesReceived.Length);
};
SecureTransfer.Client client = new SecureTransfer.Client(ClientKey, ServerKey.PublicKey,
(id, name, stream) => server.Receive(stream));
client.Upload("bla", src.Length, new MemoryStream(src, false));
Assert.AreEqual(Hash.SHA256(src), hashSent);
Assert.AreEqual(Hash.SHA256(src), Hash.SHA256(dest));
}
public void TestAbort()
{
byte[] src = new byte[1024];
SecureTransfer.Server server = new SecureTransfer.Server(ServerKey, ClientKey.PublicKey, new RegistryStorage());
SecureTransfer.Client client = new SecureTransfer.Client(ClientKey, ServerKey.PublicKey,
(id, name, stream) => server.Receive(stream));
client.Abort();
Assert.IsFalse(client.Upload("bla", src.Length, new MemoryStream(src, false)));
}
public void TestAbortByEvent()
{
SecureTransfer.Server server = new SecureTransfer.Server(ServerKey, ClientKey.PublicKey, new RegistryStorage());
SecureTransfer.Client client = new SecureTransfer.Client(ClientKey, ServerKey.PublicKey,
(id, name, stream) => server.Receive(stream));
client.ProgressChanged += (o, e) => { throw new OperationCanceledException(); };
using (TempFile file = new TempFile())
{
file.WriteAllBytes(new byte[1024]);
Assert.IsFalse(client.Upload("bla", file.TempPath));
}
}
public void TestRecieverError()
{
Exception error = null;
SecureTransfer.Server server = new SecureTransfer.Server(ServerKey, ClientKey.PublicKey, new RegistryStorage());
server.ErrorRaised += (o, e) => error = e.GetException();
try
{
server.Receive(new MemoryStream(new byte[1024]));
Assert.Fail();
}
catch (InvalidDataException) { }
Assert.IsNotNull(error);
}
public void TestDownloadFails()
{
SecureTransfer.Server server = new SecureTransfer.Server(ServerKey, ClientKey.PublicKey, new RegistryStorage());
server.MaxOutboundFileChunk = 1000;
server.DownloadBytes += (o, e) => e.SetBytes(ushort.MaxValue, null);
SecureTransfer.Client client = new SecureTransfer.Client(ClientKey, ServerKey.PublicKey,
(id, name, stream) => server.Receive(stream));
MemoryStream dest = new MemoryStream();
try
{
client.Download("bla", dest);
Assert.Fail();
}
catch (InvalidDataException) { }
}
public void TestSendingError()
{
int count = 0;
byte[] src = new byte[1024];
SecureTransfer.Server server = new SecureTransfer.Server(ServerKey, ClientKey.PublicKey, new RegistryStorage());
SecureTransfer.Client client = new SecureTransfer.Client(ClientKey, ServerKey.PublicKey,
(id, name, stream) =>
{
if (++count < 3)
{
return(server.Receive(stream));
}
//Bombs after negotiation
throw new ApplicationException();
}
);
client.Upload("bla", src.Length, new MemoryStream(src, false));
Assert.Fail();
}
