public void Bytes()
{
var rng = new StepRng(0);
Random random = RandomShim.Create(rng);
var buffer = new Byte[1024];
random.NextBytes(buffer);
var ints = MemoryMarshal.Cast <Byte, UInt64>(buffer);
for (Int32 i = 0; i < ints.Length; i++)
{
Assert.Equal((UInt64)i, ints[i]);
}
#if !NET472
random.NextBytes(buffer.AsSpan());
for (Int32 i = 0; i < ints.Length; i++)
{
Assert.Equal((UInt64)(i + ints.Length), ints[i]);
}
#endif
var maxRng = new StepRng(UInt64.MaxValue)
{
Increment = 0
};
var maxShim = RandomNumberGeneratorShim.Create(maxRng);
buffer = new Byte[1024];
maxShim.GetBytes(buffer, 200, 500);
Assert.All(buffer.Take(200), b => Assert.Equal(0, b));
Assert.All(buffer.Skip(200).Take(500), b => Assert.Equal(Byte.MaxValue, b));
Assert.All(buffer.Skip(700), b => Assert.Equal(0, b));
}
public void NonZeroBytes()
{
var rng = new SequenceRng(new UInt32[] { 0, 1, 2, 0, 1, 2, 0, 1 });
var shim = RandomNumberGeneratorShim.Create(rng);
var buffer = new Byte[35];
shim.GetNonZeroBytes(buffer);
Assert.DoesNotContain((Byte)0, buffer);
#if !NET472
shim.GetNonZeroBytes(buffer.AsSpan());
Assert.DoesNotContain((Byte)0, buffer);
#endif
}
public Byte[] ToArray()
{
if (m_spanCount == 0)
{
return(Array.Empty <Byte>());
}
else if (m_arrayCount == 0)
{
return(m_span.Slice(0, m_spanCount).ToArray());
}
var result = new Byte[m_spanCount + m_arrayCount];
m_span.CopyTo(result);
m_array.AsSpan(0, m_arrayCount).CopyTo(result.AsSpan(m_spanCount, m_arrayCount));
return(result);
}
private static Byte[] _ReadFromStream(System.IO.Stream s, int byteLen, int compression)
{
if (compression == 1)
{
using (var ss = new System.IO.Compression.DeflateStream(s, System.IO.Compression.CompressionMode.Decompress, true))
{
return(_ReadFromStream(ss, byteLen, 0));
}
}
if (compression == 0)
{
var data = new Byte[byteLen];
#if NETSTANDARD2_0
for (int i = 0; i < data.Length; ++i)
{
var value = s.ReadByte();
if (value < 0)
{
throw new System.IO.EndOfStreamException();
}
data[i] = (byte)value;
}
#else
var span = data.AsSpan();
while (span.Length > 0)
{
var r = s.Read(span);
if (r == 0)
{
throw new System.IO.EndOfStreamException();
}
span = span.Slice(r);
}
#endif
return(data);
}
throw new ArgumentException("invalid compression", nameof(compression));
}
public Boolean Hashing(ReadOnlySpan <Byte> value, ReadOnlySpan <Byte> lsalt, ReadOnlySpan <Byte> rsalt, ReadOnlySpan <Byte> lpepper, ReadOnlySpan <Byte> rpepper, UInt16 iterations, Span <Byte> destination, out Int32 written)
{
if (destination.Length < (UInt16)HashType)
{
written = 0;
return(false);
}
Byte[] buffer = new Byte[value.Length + lsalt.Length + rsalt.Length + lpepper.Length + rpepper.Length];
Span <Byte> bufferspan = buffer.AsSpan();
Int32 offset = 0;
lpepper.CopyTo(bufferspan.Slice(offset, lpepper.Length));
lsalt.CopyTo(bufferspan.Slice(offset += lpepper.Length, lsalt.Length));
value.CopyTo(bufferspan.Slice(offset += lsalt.Length, value.Length));
rsalt.CopyTo(bufferspan.Slice(offset += value.Length, rsalt.Length));
// ReSharper disable once RedundantAssignment
rpepper.CopyTo(bufferspan.Slice(offset += rsalt.Length, rpepper.Length));
Span <Byte> current = stackalloc Byte[(UInt16)HashType];
Boolean successfull = Cryptography.Hashing(buffer, current, out written, HashType);
while (--iterations > 0 && successfull)
{
successfull = Cryptography.Hashing(current, current, out written, HashType);
}
if (successfull)
{
current.CopyTo(destination);
}
else
{
written = 0;
}
return(successfull);
}
public static async Task Main(string[] args)
{
if (args.Length != 4)
{
Console.WriteLine("Usage: swvo-websocket-terminator SessId Host:Port BookmarkName LocalPort");
Console.WriteLine("Example: swvo-websocket-terminator 44E4224D3E4B1C74FCADE675803C1162 sonicwall.company.com:4433 SSH 2222");
return;
}
var sessId = args[0];
var hostPort = args[1];
var bookmarkName = args[2];
var localPort = Int32.Parse(args[3]);
var domain = hostPort.Split(':')[0];
var socket = new ClientWebSocket();
socket.Options.AddSubProtocol("binary");
socket.Options.Cookies = new CookieContainer();
socket.Options.Cookies.Add(new Cookie("SessId", sessId)
{
Domain = domain
});
try
{
await socket.ConnectAsync(new Uri($"wss://{hostPort}/ws?bookmark={WebUtility.UrlEncode(bookmarkName)}"), default);
}
catch
{
Console.WriteLine("Unable to connect to server");
return;
}
Console.WriteLine("Connected to server");
var tl = new TcpListener(IPAddress.Loopback, localPort);
tl.Start();
Console.WriteLine("Waiting for local connection");
var client = await tl.AcceptTcpClientAsync();
Console.WriteLine("Starting IO tasks");
var t1 = Task.Run(async() =>
{
var buffer = new Byte[16777216];
var i = client.GetStream();
Int32 bytesRead;
while ((bytesRead = i.Read(buffer)) > 0)
{
//Trace.WriteLine($"{bytesRead} to server");
await socket.SendAsync(buffer.AsMemory(0, bytesRead), WebSocketMessageType.Binary, true,
default);
}
});
var t2 = Task.Run(async() =>
{
var buffer = new Byte[16777216];
var o = client.GetStream();
WebSocketReceiveResult result;
while ((result = await socket.ReceiveAsync(buffer, default)).Count > 0)
{
//Trace.WriteLine($"{result.Count} to client");
o.Write(buffer.AsSpan(0, result.Count));
}
});
try
{
await t1;
await t2;
}
catch
{
// Don't care.
}
Console.WriteLine("Program complete");
}
