backup/barrier
1
0
Fork 0
mirror of https://github.com/debauchee/barrier.git synced 2026-07-04 19:06:45 +08:00
Code Issues Projects Releases Wiki Activity

added unit test to make sure IV works as we expect.

Browse Source
This commit is contained in:
Nick Bolton
2013-04-08 13:01:21 +00:00
parent 0a69c28ac5
commit b2746bc1b2
3 changed files with 140 additions and 24 deletions
Download Patch File Download Diff File Expand all files Collapse all files

108
src/test/unittests/synergy/CCryptoStreamTests.cpp
View File

@@ -20,17 +20,20 @@
#include "CMockStream.h"
#include "CMockEventQueue.h"
#include "CPacketStreamFilter.h"
using ::testing::_;
using ::testing::Invoke;
using namespace std;
void assertWrite(const void* in, UInt32 n);
UInt8 mockRead(void* out, UInt32 n);
void write_assertWrite(const void* in, UInt32 n);
UInt8 read_mockRead(void* out, UInt32 n);
void write4Read1_mockWrite(const void* in, UInt32 n);
UInt8 write4Read1_mockRead(void* out, UInt32 n);
void write1Read4_mockWrite(const void* in, UInt32 n);
UInt8 write1Read4_mockRead(void* out, UInt32 n);
void readWriteIVChanged_mockWrite(const void* in, UInt32 n);
UInt8 readWriteIVChanged_mockRead(void* out, UInt32 n);
UInt8 g_write4Read1_buffer[4];
UInt32 g_write4Read1_bufferIndex = 0;
@@ -38,6 +41,11 @@ UInt32 g_write4Read1_bufferIndex = 0;
UInt8 g_write1Read4_buffer[4];
UInt32 g_write1Read4_bufferIndex = 0;
UInt8 g_readWriteIVChanged_buffer[4];
const byte g_key[] = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"; // +\0, 32-byte/256-bit key.
const byte g_iv[] = "bbbbbbbbbbbbbbb"; // +\0, AES block size = 16
TEST(CCryptoTests, write)
{
const UInt32 size = 4;
@@ -50,7 +58,7 @@ TEST(CCryptoTests, write)
CMockEventQueue eventQueue;
CMockStream innerStream(eventQueue);
ON_CALL(innerStream, write(_, _)).WillByDefault(Invoke(assertWrite));
ON_CALL(innerStream, write(_, _)).WillByDefault(Invoke(write_assertWrite));
EXPECT_CALL(innerStream, write(_, _)).Times(1);
EXPECT_CALL(innerStream, getEventTarget()).Times(3);
EXPECT_CALL(eventQueue, removeHandlers(_)).Times(1);
@@ -58,6 +66,7 @@ TEST(CCryptoTests, write)
EXPECT_CALL(eventQueue, removeHandler(_, _)).Times(1);
CCryptoStream cs(eventQueue, &innerStream, false);
cs.setKeyWithIV(g_key, sizeof(g_key), g_iv);
cs.write(buffer, size);
}
@@ -66,7 +75,7 @@ TEST(CCryptoTests, read)
CMockEventQueue eventQueue;
CMockStream innerStream(eventQueue);
ON_CALL(innerStream, read(_, _)).WillByDefault(Invoke(mockRead));
ON_CALL(innerStream, read(_, _)).WillByDefault(Invoke(read_mockRead));
EXPECT_CALL(innerStream, read(_, _)).Times(1);
EXPECT_CALL(innerStream, getEventTarget()).Times(3);
EXPECT_CALL(eventQueue, removeHandlers(_)).Times(1);
@@ -74,6 +83,7 @@ TEST(CCryptoTests, read)
EXPECT_CALL(eventQueue, removeHandler(_, _)).Times(1);
CCryptoStream cs(eventQueue, &innerStream, false);
cs.setKeyWithIV(g_key, sizeof(g_key), g_iv);
const UInt32 size = 4;
UInt8* buffer = new UInt8[size];
@@ -100,12 +110,15 @@ TEST(CCryptoTests, write4Read1)
EXPECT_CALL(eventQueue, removeHandler(_, _)).Times(2);
CCryptoStream cs1(eventQueue, &innerStream, false);
CCryptoStream cs2(eventQueue, &innerStream, false);
cs1.setKeyWithIV(g_key, sizeof(g_key), g_iv);
cs1.write("a", 1);
cs1.write("b", 1);
cs1.write("c", 1);
cs1.write("d", 1);
CCryptoStream cs2(eventQueue, &innerStream, false);
cs2.setKeyWithIV(g_key, sizeof(g_key), g_iv);
UInt8 buffer[4];
cs2.read(buffer, 4);
@@ -131,7 +144,7 @@ TEST(CCryptoTests, write1Read4)
EXPECT_CALL(eventQueue, removeHandler(_, _)).Times(2);
CCryptoStream cs1(eventQueue, &innerStream, false);
CCryptoStream cs2(eventQueue, &innerStream, false);
cs1.setKeyWithIV(g_key, sizeof(g_key), g_iv);
UInt8 bufferIn[4];
bufferIn[0] = 'a';
@@ -139,6 +152,9 @@ TEST(CCryptoTests, write1Read4)
bufferIn[2] = 'c';
bufferIn[3] = 'd';
cs1.write(bufferIn, 4);
CCryptoStream cs2(eventQueue, &innerStream, false);
cs2.setKeyWithIV(g_key, sizeof(g_key), g_iv);
UInt8 bufferOut[4];
cs2.read(&bufferOut[0], 1);
@@ -152,24 +168,64 @@ TEST(CCryptoTests, write1Read4)
EXPECT_EQ('d', bufferOut[3]);
}
TEST(CCryptoTests, readWriteIVChanged)
{
CMockEventQueue eventQueue;
CMockStream innerStream(eventQueue);
ON_CALL(innerStream, write(_, _)).WillByDefault(Invoke(readWriteIVChanged_mockWrite));
ON_CALL(innerStream, read(_, _)).WillByDefault(Invoke(readWriteIVChanged_mockRead));
EXPECT_CALL(innerStream, write(_, _)).Times(1);
EXPECT_CALL(innerStream, read(_, _)).Times(1);
EXPECT_CALL(innerStream, getEventTarget()).Times(6);
EXPECT_CALL(eventQueue, removeHandlers(_)).Times(2);
EXPECT_CALL(eventQueue, adoptHandler(_, _, _)).Times(2);
EXPECT_CALL(eventQueue, removeHandler(_, _)).Times(2);
const byte iv1[] = "bbbbbbbbbbbbbbb";
const byte iv2[] = "ccccccccccccccc";
CCryptoStream cs1(eventQueue, &innerStream, false);
cs1.setKeyWithIV(g_key, sizeof(g_key), iv1);
UInt8 bufferIn[4];
bufferIn[0] = 'a';
bufferIn[1] = 'b';
bufferIn[2] = 'c';
bufferIn[3] = 'd';
cs1.write(bufferIn, 4);
CCryptoStream cs2(eventQueue, &innerStream, false);
cs2.setKeyWithIV(g_key, sizeof(g_key), iv2);
UInt8 bufferOut[4];
cs2.read(bufferOut, 4);
// assert that the values have changed.
EXPECT_NE('a', bufferOut[0]);
EXPECT_NE('b', bufferOut[1]);
EXPECT_NE('c', bufferOut[2]);
EXPECT_NE('d', bufferOut[3]);
}
void
assertWrite(const void* in, UInt32 n)
write_assertWrite(const void* in, UInt32 n)
{
UInt8* buffer = static_cast<UInt8*>(const_cast<void*>(in));
EXPECT_EQ(55, buffer[0]);
EXPECT_EQ(142, buffer[1]);
EXPECT_EQ(189, buffer[2]);
EXPECT_EQ(237, buffer[3]);
EXPECT_EQ(8, buffer[0]);
EXPECT_EQ(58, buffer[1]);
EXPECT_EQ(151, buffer[2]);
EXPECT_EQ(33, buffer[3]);
}
UInt8
mockRead(void* out, UInt32 n)
read_mockRead(void* out, UInt32 n)
{
UInt8* buffer = static_cast<UInt8*>(out);
buffer[0] = 55;
buffer[1] = 142;
buffer[2] = 189;
buffer[3] = 237;
buffer[0] = 8;
buffer[1] = 58;
buffer[2] = 151;
buffer[3] = 33;
return n;
}
@@ -209,3 +265,23 @@ write1Read4_mockRead(void* out, UInt32 n)
return 1;
}
void
readWriteIVChanged_mockWrite(const void* in, UInt32 n)
{
UInt8* buffer = static_cast<UInt8*>(const_cast<void*>(in));
g_readWriteIVChanged_buffer[0] = buffer[0];
g_readWriteIVChanged_buffer[1] = buffer[1];
g_readWriteIVChanged_buffer[2] = buffer[2];
g_readWriteIVChanged_buffer[3] = buffer[3];
}
UInt8
readWriteIVChanged_mockRead(void* out, UInt32 n)
{
UInt8* buffer = static_cast<UInt8*>(out);
buffer[0] = g_readWriteIVChanged_buffer[0];
buffer[1] = g_readWriteIVChanged_buffer[1];
buffer[2] = g_readWriteIVChanged_buffer[2];
buffer[3] = g_readWriteIVChanged_buffer[3];
return 4;
}