backup/barrier
1
0
Fork 0
mirror of https://github.com/debauchee/barrier.git synced 2026-05-11 10:56:25 +08:00
Code Issues Projects Releases Wiki Activity

Jerry's patch for password hash and custom mode (via command line).

Browse Source
This commit is contained in:
Nick Bolton
2013-04-09 21:57:07 +00:00
parent 7010de9cc4
commit 880819fab7
20 changed files with 557 additions and 108 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
src/test/unittests/io/CMockCryptoStream.h
View File

@@ -19,11 +19,14 @@
#include <gmock/gmock.h>
#include "CCryptoStream.h"
#include "CCryptoOptions.h"
class CMockCryptoStream : public CCryptoStream
{
public:
CMockCryptoStream(IEventQueue* eventQueue, IStream* stream) : CCryptoStream(eventQueue, stream, false) { }
CMockCryptoStream(IEventQueue* eventQueue, IStream* stream) :
CCryptoStream(eventQueue, stream, CCryptoOptions("gcm", "stub"), false) { }
MOCK_METHOD2(read, UInt32(void*, UInt32));
MOCK_METHOD2(write, void(const void*, UInt32));
};

4
src/test/unittests/server/CClientProxyTests.cpp
View File

@@ -26,9 +26,6 @@ using ::testing::_;
using ::testing::NiceMock;
using ::testing::Invoke;
const byte g_key[] = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"; // +\0, 32-byte/256-bit key.
const byte g_iv[] = "bbbbbbbbbbbbbb"; // +\0, AES block size = 16
const UInt8 cryptoIvWrite_bufferLen = 200;
UInt8 cryptoIvWrite_buffer[cryptoIvWrite_bufferLen];
UInt32 cryptoIvWrite_bufferIndex = 0;
@@ -42,7 +39,6 @@ TEST(CClientProxyTests, cryptoIvWrite)
NiceMock<CMockStream> innerStream;
NiceMock<CMockServer> server;
NiceMock<CMockCryptoStream>* stream = new NiceMock<CMockCryptoStream>(&eventQueue, &innerStream);
stream->setKeyWithIv(g_key, sizeof(g_key), g_iv);
ON_CALL(*stream, write(_, _)).WillByDefault(Invoke(cryptoIv_mockWrite));

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

@@ -27,6 +27,8 @@ using ::testing::NiceMock;
using namespace std;
const byte kIv[] = "aaaaaaaaaaaaaa"; // +\0, AES block size = 16
UInt8 g_write_buffer[4];
void write_mockWrite(const void* in, UInt32 n);
@@ -47,14 +49,11 @@ UInt8 g_readWriteIvChanged_buffer[4];
UInt32 g_readWriteIvChangeTrigger_writeBufferIndex = 0;
UInt32 g_readWriteIvChangeTrigger_readBufferIndex = 0;
void readWriteIvChanged_mockWrite(const void* in, UInt32 n);
UInt8 readWriteIvChanged_mockRead(void* out, UInt32 n);
UInt8 readWriteIvChanged_mockRead(void* out, UInt32 n);
UInt8 g_readWriteIvChangeTrigger_buffer[4 + 4 + 16]; // abcd, DCIV, 16-byte IV
void readWriteIvChangeTrigger_mockWrite(const void* in, UInt32 n);
UInt8 readWriteIvChangeTrigger_mockRead(void* out, UInt32 n);
const byte g_key[] = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"; // +\0, 32-byte/256-bit key.
const byte g_iv[] = "bbbbbbbbbbbbbb"; // +\0, AES block size = 16
UInt8 readWriteIvChangeTrigger_mockRead(void* out, UInt32 n);
TEST(CCryptoTests, write)
{
@@ -67,33 +66,35 @@ TEST(CCryptoTests, write)
NiceMock<CMockEventQueue> eventQueue;
NiceMock<CMockStream> innerStream;
CCryptoOptions options("ctr", "mock");
ON_CALL(innerStream, write(_, _)).WillByDefault(Invoke(write_mockWrite));
CCryptoStream cs(&eventQueue, &innerStream, false);
cs.setKeyWithIv(g_key, sizeof(g_key), g_iv);
CCryptoStream cs(&eventQueue, &innerStream, options, false);
cs.setIv(kIv);
cs.write(buffer, size);
EXPECT_EQ(254, g_write_buffer[0]);
EXPECT_EQ(44, g_write_buffer[1]);
EXPECT_EQ(187, g_write_buffer[2]);
EXPECT_EQ(253, g_write_buffer[3]);
EXPECT_EQ(198, g_write_buffer[0]);
EXPECT_EQ(62, g_write_buffer[1]);
EXPECT_EQ(15, g_write_buffer[2]);
EXPECT_EQ(87, g_write_buffer[3]);
}
TEST(CCryptoTests, read)
{
NiceMock<CMockEventQueue> eventQueue;
NiceMock<CMockStream> innerStream;
CCryptoOptions options("ctr", "mock");
ON_CALL(innerStream, read(_, _)).WillByDefault(Invoke(read_mockRead));
CCryptoStream cs(&eventQueue, &innerStream, false);
cs.setKeyWithIv(g_key, sizeof(g_key), g_iv);
g_read_buffer[0] = 254;
g_read_buffer[1] = 44;
g_read_buffer[2] = 187;
g_read_buffer[3] = 253;
CCryptoStream cs(&eventQueue, &innerStream, options, false);
cs.setIv(kIv);
g_read_buffer[0] = 198;
g_read_buffer[1] = 62;
g_read_buffer[2] = 15;
g_read_buffer[3] = 87;
const UInt32 size = 4;
UInt8* buffer = new UInt8[size];
@@ -109,20 +110,21 @@ TEST(CCryptoTests, write4Read1)
{
NiceMock<CMockEventQueue> eventQueue;
NiceMock<CMockStream> innerStream;
CCryptoOptions options("ctr", "mock");
ON_CALL(innerStream, write(_, _)).WillByDefault(Invoke(write4Read1_mockWrite));
ON_CALL(innerStream, read(_, _)).WillByDefault(Invoke(write4Read1_mockRead));
CCryptoStream cs1(&eventQueue, &innerStream, false);
cs1.setKeyWithIv(g_key, sizeof(g_key), g_iv);
CCryptoStream cs1(&eventQueue, &innerStream, options, false);
cs1.setIv(kIv);
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);
CCryptoStream cs2(&eventQueue, &innerStream, options, false);
cs2.setIv(kIv);
UInt8 buffer[4];
cs2.read(buffer, 4);
@@ -137,12 +139,13 @@ TEST(CCryptoTests, write1Read4)
{
NiceMock<CMockEventQueue> eventQueue;
NiceMock<CMockStream> innerStream;
CCryptoOptions options("ctr", "mock");
ON_CALL(innerStream, write(_, _)).WillByDefault(Invoke(write1Read4_mockWrite));
ON_CALL(innerStream, read(_, _)).WillByDefault(Invoke(write1Read4_mockRead));
CCryptoStream cs1(&eventQueue, &innerStream, false);
cs1.setKeyWithIv(g_key, sizeof(g_key), g_iv);
CCryptoStream cs1(&eventQueue, &innerStream, options, false);
cs1.setIv(kIv);
UInt8 bufferIn[4];
bufferIn[0] = 'a';
@@ -151,8 +154,8 @@ TEST(CCryptoTests, write1Read4)
bufferIn[3] = 'd';
cs1.write(bufferIn, 4);
CCryptoStream cs2(&eventQueue, &innerStream, false);
cs2.setKeyWithIv(g_key, sizeof(g_key), g_iv);
CCryptoStream cs2(&eventQueue, &innerStream, options, false);
cs2.setIv(kIv);
UInt8 bufferOut[4];
cs2.read(&bufferOut[0], 1);
@@ -170,15 +173,16 @@ TEST(CCryptoTests, readWriteIvChanged)
{
NiceMock<CMockEventQueue> eventQueue;
NiceMock<CMockStream> innerStream;
CCryptoOptions options("ctr", "mock");
ON_CALL(innerStream, write(_, _)).WillByDefault(Invoke(readWriteIvChanged_mockWrite));
ON_CALL(innerStream, read(_, _)).WillByDefault(Invoke(readWriteIvChanged_mockRead));
const byte iv1[] = "bbbbbbbbbbbbbbb";
const byte iv1[] = "bbbbbbbbbbbbbbb";
const byte iv2[] = "ccccccccccccccc";
CCryptoStream cs1(&eventQueue, &innerStream, false);
cs1.setKeyWithIv(g_key, sizeof(g_key), iv1);
CCryptoStream cs1(&eventQueue, &innerStream, options, false);
cs1.setIv(iv1);
UInt8 bufferIn[4];
bufferIn[0] = 'a';
@@ -187,8 +191,8 @@ TEST(CCryptoTests, readWriteIvChanged)
bufferIn[3] = 'd';
cs1.write(bufferIn, 4);
CCryptoStream cs2(&eventQueue, &innerStream, false);
cs2.setKeyWithIv(g_key, sizeof(g_key), iv2);
CCryptoStream cs2(&eventQueue, &innerStream, options, false);
cs1.setIv(iv2);
UInt8 bufferOut[4];
cs2.read(bufferOut, 4);
@@ -215,6 +219,20 @@ TEST(CCryptoTests, readWriteIvChanged)
EXPECT_EQ('d', bufferOut[3]);
}
TEST(CCryptoTests, createKey)
{
byte hash1[16];
CCryptoStream::createKey(hash1, "MockLongPassword", 16, 16);
EXPECT_EQ(hash1[0], 149);
EXPECT_EQ(hash1[15], 235);
byte hash2[32];
CCryptoStream::createKey(hash2, "MockLongPassword", 32, 16);
EXPECT_EQ(hash2[0], 149);
EXPECT_EQ(hash2[15], 235);
EXPECT_EQ(hash2[31], 7);
}
void
write_mockWrite(const void* in, UInt32 n)
{