public void GetResetHeadAtCapacityTest()
{
// arrange
ByteCircularBuffer target;
byte expected;
byte actual;
int expectedHead;
target = new ByteCircularBuffer(3);
expected = 3;
expectedHead = 0;
target.Put(1);
target.Put(2);
target.Put(3);
target.Get();
target.Get();
// act
actual = target.Get();
// assert
actual.Should().
Be(expected);
target.Head.Should().
Be(expectedHead);
}
public override void Encrypt(byte[] buf, int length, byte[] outbuf, out int outlength)
{
Debug.Assert(_encCircularBuffer != null, "_encCircularBuffer != null");
_encCircularBuffer.Put(buf, 0, length);
outlength = 0;
Logging.Debug("---Start Encryption");
if (!_encryptSaltSent)
{
_encryptSaltSent = true;
// Generate salt
byte[] saltBytes = new byte[saltLen];
randBytes(saltBytes, saltLen);
InitCipher(saltBytes, true, false);
Array.Copy(saltBytes, 0, outbuf, 0, saltLen);
outlength = saltLen;
Logging.Debug($"_encryptSaltSent outlength {outlength}");
}
if (!_tcpRequestSent)
{
_tcpRequestSent = true;
// The first TCP request
int encAddrBufLength;
byte[] encAddrBufBytes = new byte[AddrBufLength + tagLen * 2 + CHUNK_LEN_BYTES];
byte[] addrBytes = _encCircularBuffer.Get(AddrBufLength);
ChunkEncrypt(addrBytes, AddrBufLength, encAddrBufBytes, out encAddrBufLength);
Debug.Assert(encAddrBufLength == AddrBufLength + tagLen * 2 + CHUNK_LEN_BYTES);
Array.Copy(encAddrBufBytes, 0, outbuf, outlength, encAddrBufLength);
outlength += encAddrBufLength;
Logging.Debug($"_tcpRequestSent outlength {outlength}");
}
// handle other chunks
while (true)
{
uint bufSize = (uint)_encCircularBuffer.Size;
if (bufSize <= 0)
{
return;
}
var chunklength = (int)Math.Min(bufSize, MaxChunkSize);
byte[] chunkBytes = _encCircularBuffer.Get(chunklength);
int encChunkLength;
byte[] encChunkBytes = new byte[chunklength + tagLen * 2 + CHUNK_LEN_BYTES];
ChunkEncrypt(chunkBytes, chunklength, encChunkBytes, out encChunkLength);
Debug.Assert(encChunkLength == chunklength + tagLen * 2 + CHUNK_LEN_BYTES);
PerfByteCopy(encChunkBytes, 0, outbuf, outlength, encChunkLength);
outlength += encChunkLength;
Logging.Debug("chunks enc outlength " + outlength);
bufSize = (uint)_encCircularBuffer.Size;
if (bufSize <= 0)
{
Logging.Debug("No more data to encrypt, leaving");
return;
}
}
}
public override void Encrypt(byte[] buf, int length, byte[] outbuf, out int outlength)
{
int cipherOffset = 0;
Debug.Assert(_encCircularBuffer != null, "_encCircularBuffer != null");
_encCircularBuffer.Put(buf, 0, length);
if (!_encryptIVSent)
{
// Generate IV
byte[] ivBytes = new byte[ivLen];
randBytes(ivBytes, ivLen);
initCipher(ivBytes, true);
Array.Copy(ivBytes, 0, outbuf, 0, ivLen);
cipherOffset = ivLen;
_encryptIVSent = true;
}
int size = _encCircularBuffer.Size;
byte[] plain = _encCircularBuffer.Get(size);
byte[] cipher = new byte[size];
cipherUpdate(true, size, plain, cipher);
Buffer.BlockCopy(cipher, 0, outbuf, cipherOffset, size);
outlength = size + cipherOffset;
}
public override void Encrypt(byte[] buf, int length, byte[] outbuf, out int outlength)
{
//none rc4
if (length == 0)
{
outlength = 0;
return;
}
var cipherOffset = 0;
_encCircularBuffer.Put(buf, 0, length);
if (!_encryptIVSent)
{
InitCipher(_iv, true);
Array.Copy(_iv, 0, outbuf, 0, ivLen);
cipherOffset = ivLen;
_encryptIVSent = true;
}
var size = _encCircularBuffer.Size;
var plain = _encCircularBuffer.Get(size);
var cipher = new byte[size];
CipherUpdate(true, size, plain, cipher);
Buffer.BlockCopy(cipher, 0, outbuf, cipherOffset, size);
outlength = size + cipherOffset;
}
public void GetEmptyExceptionTest()
{
// arrange
ByteCircularBuffer target;
target = new ByteCircularBuffer(10);
target.Put(1);
target.Put(2);
target.Put(3);
target.Get();
target.Get();
target.Get();
// act & assert
Assert.That(() => target.Get(), Throws.TypeOf <InvalidOperationException>());
}
public void GetWithArrayTest()
{
// arrange
ByteCircularBuffer target;
int expectedSize;
int expectedHead;
int expectedTail;
int expectedElements;
int actualElements;
byte[] expected;
byte[] actual;
target = new ByteCircularBuffer(10);
expected = new byte[]
{
1,
2
};
expectedHead = 2;
expectedSize = 1;
expectedTail = 3;
expectedElements = 2;
actual = new byte[expectedElements];
target.Put(1);
target.Put(2);
target.Put(3);
// act
actualElements = target.Get(actual);
// assert
actualElements.Should().
Be(expectedElements);
actual.Should().
Equal(expected);
target.Contains(1).
Should().
BeFalse();
target.Contains(2).
Should().
BeFalse();
target.Contains(3).
Should().
BeTrue();
target.Head.Should().
Be(expectedHead);
target.Tail.Should().
Be(expectedTail);
target.Size.Should().
Be(expectedSize);
}
public void GetNextTest()
{
// arrange
ByteCircularBuffer target;
byte expected;
byte actual;
target = new ByteCircularBuffer(10);
target.Put(1);
target.Put(2);
target.Put(3);
target.Get();
expected = 2;
// act
actual = target.Get();
// assert
actual.Should().
Be(expected);
}
public void GetTest()
{
// arrange
ByteCircularBuffer target;
int expectedSize;
int expectedHead;
int expectedTail;
byte expected;
byte actual;
target = new ByteCircularBuffer(10);
expected = 1;
expectedHead = 1;
expectedSize = 2;
expectedTail = 3;
target.Put(1);
target.Put(2);
target.Put(3);
// act
actual = target.Get();
// assert
actual.Should().
Be(expected);
target.Contains(1).
Should().
BeFalse();
target.Contains(2).
Should().
BeTrue();
target.Contains(3).
Should().
BeTrue();
target.Head.Should().
Be(expectedHead);
target.Tail.Should().
Be(expectedTail);
target.Size.Should().
Be(expectedSize);
}
public void ContainsAfterGetTest()
{
// arrange
ByteCircularBuffer target;
bool actual;
target = new ByteCircularBuffer(10);
target.Put(1);
target.Put(2);
target.Put(3);
target.Get();
// act
actual = target.Contains(1);
// assert
actual.Should().
BeFalse();
}
public override void Decrypt(byte[] buf, int length, byte[] outbuf, out int outlength)
{
Debug.Assert(_decCircularBuffer != null, "_circularBuffer != null");
_decCircularBuffer.Put(buf, 0, length);
if (!_decryptIVReceived)
{
if (_decCircularBuffer.Size <= ivLen)
{
// we need more data
outlength = 0;
return;
}
// start decryption
_decryptIVReceived = true;
byte[] iv = _decCircularBuffer.Get(ivLen);
initCipher(iv, false);
}
byte[] cipher = _decCircularBuffer.ToArray();
cipherUpdate(false, cipher.Length, cipher, outbuf);
_decCircularBuffer.Clear();
outlength = cipher.Length;
// done the decryption
}
public override void Decrypt(byte[] buf, int length, byte[] outbuf, out int outlength)
{
_decCircularBuffer.Put(buf, 0, length);
if (!_decryptIVReceived)
{
if (_decCircularBuffer.Size <= ivLen)
{
// we need more data
outlength = 0;
return;
}
// start decryption
_decryptIVReceived = true;
var iv = ivLen == 0 ? new byte[0] : _decCircularBuffer.Get(ivLen); //none rc4
InitCipher(iv, false);
}
var cipher = _decCircularBuffer.ToArray();
CipherUpdate(false, cipher.Length, cipher, outbuf);
// move pointer only
_decCircularBuffer.Skip(_decCircularBuffer.Size);
outlength = cipher.Length;
// done the decryption
}
public void EmptyBufferTest()
{
// arrange
ByteCircularBuffer target;
byte[] expected;
byte[] actual;
expected = this.GenerateRandomData(100);
target = new ByteCircularBuffer(expected.Length);
target.Put(expected);
actual = new byte[target.Size];
// act
target.Get(actual);
// assert
actual.Should().
Equal(expected);
target.Size.Should().
Be(0);
}
public override void Decrypt(byte[] buf, int length, byte[] outbuf, out int outlength)
{
Debug.Assert(_decCircularBuffer != null, "_decCircularBuffer != null");
int bufSize;
outlength = 0;
// drop all into buffer
_decCircularBuffer.Put(buf, 0, length);
Logging.Debug("---Start Decryption");
if (!_decryptSaltReceived)
{
bufSize = _decCircularBuffer.Size;
// check if we get the leading salt
if (bufSize <= saltLen)
{
// need more
return;
}
_decryptSaltReceived = true;
byte[] salt = _decCircularBuffer.Get(saltLen);
InitCipher(salt, false, false);
Logging.Debug("get salt len " + saltLen);
}
// handle chunks
while (true)
{
bufSize = _decCircularBuffer.Size;
// check if we have any data
if (bufSize <= 0)
{
Logging.Debug("No data in _decCircularBuffer");
return;
}
// first get chunk length
if (bufSize <= CHUNK_LEN_BYTES + tagLen)
{
// so we only have chunk length and its tag?
return;
}
#region Chunk Decryption
byte[] encLenBytes = _decCircularBuffer.Peek(CHUNK_LEN_BYTES + tagLen);
uint decChunkLenLength = 0;
byte[] decChunkLenBytes = new byte[CHUNK_LEN_BYTES];
// try to dec chunk len
cipherDecrypt(encLenBytes, CHUNK_LEN_BYTES + (uint)tagLen, decChunkLenBytes, ref decChunkLenLength);
Debug.Assert(decChunkLenLength == CHUNK_LEN_BYTES);
// finally we get the real chunk len
ushort chunkLen = (ushort)IPAddress.NetworkToHostOrder((short)BitConverter.ToUInt16(decChunkLenBytes, 0));
if (chunkLen > CHUNK_LEN_MASK)
{
// we get invalid chunk
Logging.Error($"Invalid chunk length: {chunkLen}");
throw new CryptoErrorException();
}
Logging.Debug("Get the real chunk len:" + chunkLen);
bufSize = _decCircularBuffer.Size;
if (bufSize < CHUNK_LEN_BYTES + tagLen /* we haven't remove them */ + chunkLen + tagLen)
{
Logging.Debug("No more data to decrypt one chunk");
return;
}
IncrementNonce(false);
// we have enough data to decrypt one chunk
// drop chunk len and its tag from buffer
_decCircularBuffer.Skip(CHUNK_LEN_BYTES + tagLen);
byte[] encChunkBytes = _decCircularBuffer.Get(chunkLen + tagLen);
byte[] decChunkBytes = new byte[chunkLen];
uint decChunkLen = 0;
cipherDecrypt(encChunkBytes, chunkLen + (uint)tagLen, decChunkBytes, ref decChunkLen);
Debug.Assert(decChunkLen == chunkLen);
IncrementNonce(false);
#endregion
// output to outbuf
Buffer.BlockCopy(decChunkBytes, 0, outbuf, outlength, (int)decChunkLen);
outlength += (int)decChunkLen;
Logging.Debug("aead dec outlength " + outlength);
if (outlength + 100 > TCPHandler.BufferSize)
{
Logging.Debug("dec outbuf almost full, giving up");
return;
}
bufSize = _decCircularBuffer.Size;
// check if we already done all of them
if (bufSize <= 0)
{
Logging.Debug("No data in _decCircularBuffer, already all done");
return;
}
}
}
public override void Encrypt(byte[] buf, int length, byte[] outbuf, out int outlength)
{
Debug.Assert(_encCircularBuffer != null, "_encCircularBuffer != null");
_encCircularBuffer.Put(buf, 0, length);
outlength = 0;
logger.Trace("---Start Encryption");
if (!_encryptSaltSent)
{
_encryptSaltSent = true;
// Generate salt
byte[] saltBytes = new byte[saltLen];
randBytes(saltBytes, saltLen);
InitCipher(saltBytes, true, false);
Array.Copy(saltBytes, 0, outbuf, 0, saltLen);
outlength = saltLen;
logger.Trace($"_encryptSaltSent outlength {outlength}");
}
if (!_tcpRequestSent)
{
_tcpRequestSent = true;
// The first TCP request
int encAddrBufLength;
byte[] encAddrBufBytes = new byte[AddrBufLength + tagLen * 2 + CHUNK_LEN_BYTES];
byte[] addrBytes = _encCircularBuffer.Get(AddrBufLength);
ChunkEncrypt(addrBytes, AddrBufLength, encAddrBufBytes, out encAddrBufLength);
Debug.Assert(encAddrBufLength == AddrBufLength + tagLen * 2 + CHUNK_LEN_BYTES);
Array.Copy(encAddrBufBytes, 0, outbuf, outlength, encAddrBufLength);
outlength += encAddrBufLength;
logger.Trace($"_tcpRequestSent outlength {outlength}");
}
// handle other chunks
while (true)
{
uint bufSize = (uint)_encCircularBuffer.Size;
if (bufSize <= 0)
{
return;
}
var chunklength = (int)Math.Min(bufSize, CHUNK_LEN_MASK);
byte[] chunkBytes = _encCircularBuffer.Get(chunklength);
int encChunkLength;
byte[] encChunkBytes = new byte[chunklength + tagLen * 2 + CHUNK_LEN_BYTES];
ChunkEncrypt(chunkBytes, chunklength, encChunkBytes, out encChunkLength);
Debug.Assert(encChunkLength == chunklength + tagLen * 2 + CHUNK_LEN_BYTES);
Buffer.BlockCopy(encChunkBytes, 0, outbuf, outlength, encChunkLength);
outlength += encChunkLength;
logger.Trace("chunks enc outlength " + outlength);
// check if we have enough space for outbuf
if (outlength + TCPHandler.ChunkOverheadSize > TCPHandler.BufferSize)
{
logger.Trace("enc outbuf almost full, giving up");
return;
}
bufSize = (uint)_encCircularBuffer.Size;
if (bufSize <= 0)
{
logger.Trace("No more data to encrypt, leaving");
return;
}
}
}
public override void Encrypt(byte[] buf, int length, byte[] outbuf, out int outlength)
{
Debug.Assert(_encCircularBuffer != null, "_encCircularBuffer != null");
_encCircularBuffer.Put(buf, 0, length);
outlength = 0;
Logging.Debug("---Start Encryption");
if (!_encryptSaltSent)
{
_encryptSaltSent = true;
// Generate salt
byte[] saltBytes = new byte[saltLen];
randBytes(saltBytes, saltLen);
InitCipher(saltBytes, true, false);
Array.Copy(saltBytes, 0, outbuf, 0, saltLen);
outlength = saltLen;
Logging.Debug($"_encryptSaltSent outlength {outlength}");
}
if (!_tcpRequestSent)
{
_tcpRequestSent = true;
// The first TCP request
int encAddrBufLength;
byte[] garbage = GetGarbage(AddrBufLength, true);
Logging.Debug("garbage len: " + garbage.Length);
byte[] encAddrBufBytes = new byte[garbage.Length + AddrBufLength + tagLen * 2 + CHUNK_LEN_BYTES];
byte[] addrBytes = _encCircularBuffer.Get(AddrBufLength);
byte[] addrWithGarbage = new byte[AddrBufLength + garbage.Length];
PerfByteCopy(garbage, 0, addrWithGarbage, 0, garbage.Length);
PerfByteCopy(addrBytes, 0, addrWithGarbage, garbage.Length, AddrBufLength);
ChunkEncrypt(addrWithGarbage, AddrBufLength + garbage.Length, encAddrBufBytes, out encAddrBufLength);
Debug.Assert(encAddrBufLength == garbage.Length + AddrBufLength + tagLen * 2 + CHUNK_LEN_BYTES);
Array.Copy(encAddrBufBytes, 0, outbuf, outlength, encAddrBufLength);
outlength += encAddrBufLength;
Logging.Debug($"_tcpRequestSent outlength {outlength}");
}
// handle other chunks
while (true)
{
uint bufSize = (uint)_encCircularBuffer.Size;
if (bufSize <= 0)
{
return;
}
var chunklength = (int)Math.Min(bufSize, CHUNK_MAX_LEN_WITH_GARBAGE);
byte[] chunkBytes = _encCircularBuffer.Get(chunklength);
byte[] garbage = GetGarbage(chunklength, false);
int garbageLength = garbage.Length;
Logging.Debug("garbage len: " + garbageLength);
byte[] chunkWithGarbage = new byte[chunklength + garbageLength];
PerfByteCopy(garbage, 0, chunkWithGarbage, 0, garbageLength);
PerfByteCopy(chunkBytes, 0, chunkWithGarbage, garbageLength, chunklength);
chunklength += garbageLength;
int encChunkLength;
byte[] encChunkBytes = new byte[chunklength + tagLen * 2 + CHUNK_LEN_BYTES];
ChunkEncrypt(chunkWithGarbage, chunklength, encChunkBytes, out encChunkLength);
Debug.Assert(encChunkLength == chunklength + tagLen * 2 + CHUNK_LEN_BYTES);
PerfByteCopy(encChunkBytes, 0, outbuf, outlength, encChunkLength);
outlength += encChunkLength;
Logging.Debug("chunks enc outlength " + outlength);
// check if we have enough space for outbuf
if (outlength + ChunkOverheadSize > TCPRelay.BufferSize)
{
Logging.Debug("enc outbuf almost full, giving up");
return;
}
bufSize = (uint)_encCircularBuffer.Size;
if (bufSize <= 0)
{
Logging.Debug("No more data to encrypt, leaving");
return;
}
}
}
