std::vector<typename LocalDataStoreEntry<QueryType, ValueType,
EvaluatorTranslatorFilterType>::SequencedValue> LocalDataStoreEntry<
QueryType, ValueType, EvaluatorTranslatorFilterType>::Load(
const Query& query) const {
std::vector<SequencedValue> matches;
if(query.GetSnapshotLimit().GetSize() == 0) {
return matches;
}
if(query.GetRange().GetStart() == Sequence::Present() ||
query.GetRange().GetStart() == Sequence::Last()) {
return matches;
}
auto& startPoint = query.GetRange().GetStart();
auto& endPoint = query.GetRange().GetEnd();
auto filter = m_translator(query.GetFilter());
m_values.With(
[&] (const typename ValueList::List& values) {
if(query.GetSnapshotLimit().GetType() == SnapshotLimit::Type::TAIL) {
for(const auto& value : boost::adaptors::reverse(values)) {
if(RangePointGreaterOrEqual(value, startPoint) &&
RangePointLesserOrEqual(value, endPoint) &&
TestFilter(*filter, *value)) {
matches.push_back(value);
if(static_cast<int>(matches.size()) >=
query.GetSnapshotLimit().GetSize()) {
break;
}
}
}
} else {
for(const auto& value : values) {
if(RangePointGreaterOrEqual(value, startPoint) &&
RangePointLesserOrEqual(value, endPoint) &&
TestFilter(*filter, *value)) {
matches.push_back(value);
if(static_cast<int>(matches.size()) >=
query.GetSnapshotLimit().GetSize()) {
break;
}
}
}
}
});
if(query.GetSnapshotLimit().GetType() == SnapshotLimit::Type::TAIL) {
std::reverse(matches.begin(), matches.end());
}
return matches;
}
bool TestModeIV(SymmetricCipher &e, SymmetricCipher &d)
{
SecByteBlock lastIV, iv(e.IVSize());
StreamTransformationFilter filter(e, new StreamTransformationFilter(d));
byte plaintext[20480];
for (unsigned int i=1; i<sizeof(plaintext); i*=2)
{
e.GetNextIV(GlobalRNG(), iv);
if (iv == lastIV)
return false;
else
lastIV = iv;
e.Resynchronize(iv);
d.Resynchronize(iv);
unsigned int length = STDMAX(GlobalRNG().GenerateWord32(0, i), (word32)e.MinLastBlockSize());
GlobalRNG().GenerateBlock(plaintext, length);
if (!TestFilter(filter, plaintext, length, plaintext, length))
return false;
}
return true;
}
// Our main test program
int
main(int argc,TCHAR* argv[], TCHAR* /*envp[]*/)
{
int nRetCode = 0;
HMODULE hModule = ::GetModuleHandle(NULL);
InitializeCriticalSection(&std_stream);
if(hModule == NULL)
{
_tprintf(_T("Fatal Error: GetModuleHandle failed\n"));
nRetCode = 1;
}
else
{
// initialize MFC and print and error on failure
if (!AfxWinInit(hModule, NULL, ::GetCommandLine(), 0))
{
_tprintf(_T("Fatal Error: MFC initialization failed\n"));
nRetCode = 1;
}
else
{
printf("TESTPROGAM: MARLIN SERVER\n");
printf("=========================\n");
printf("\n");
printf("Version string: %s\n",MARLIN_SERVER_VERSION);
printf("----------------------------------\n");
printf("\n");
// See if we must do the standalone WebServiceServer test
// Or that we should do the flat HTTPServer tests
if(argc >= 2)
{
if(_stricmp(argv[1],"/ws") == 0)
{
CString contract = "http://interface.marlin.org/testing/";
printf("WebServiceServer test for \"%s\"\n",contract.GetString());
printf("----------------------------------------------------------------\n");
printf("\n");
// Test the Interface
nRetCode = TestWebServiceServer(NULL,contract,logLevel);
}
}
else
{
HTTPServer* server = nullptr;
LogAnalysis* logfile = nullptr;
if(StartServer(server,logfile))
{
// Fire up all of our test sites
int errors = 0;
// Individual tests
errors += Test_CrackURL();
errors += Test_HTTPTime();
errors += TestThreadPool(server->GetThreadPool());
// HTTP tests
errors += TestBaseSite(server);
errors += TestSecureSite(server);
errors += TestClientCertificate(server,true);
errors += TestCookies(server);
errors += TestFormData(server);
errors += TestJsonData(server);
errors += TestInsecure(server);
errors += TestPushEvents(server);
errors += TestBodySigning(server);
errors += TestBodyEncryption(server);
errors += TestMessageEncryption(server);
errors += TestReliable(server);
errors += TestReliableBA(server);
errors += TestToken(server);
errors += TestSubSites(server);
errors += TestFilter(server);
errors += TestPatch(server);
errors += TestCompression(server);
errors += TestAsynchrone(server);
errors += TestWebSocket(server);
// Test the WebServiceServer program generation
CString contract = "http://interface.marlin.org/testing/";
errors += TestJsonServer(server,contract,logLevel);
errors += TestWebServiceServer(server,contract,logLevel);
// See if we should wait for testing to occur
if(errors)
{
printf("\n"
"SERVER (OR PROGRAMMING) IN ERROR STATE!!\n"
"%d sites not correctly started\n"
"\n",errors);
}
else
{
printf("\n"
"Server running....\n"
"Waiting to be called by test clients...\n"
"\n");
// Wait for key to occur
WaitForKey();
}
// Try to stop the WebSocket
// errors += StopWebSocket();
//
// Try to stop the subsites
errors += StopSubsites(server);
// Testing the errorlog function
server->ErrorLog(__FUNCTION__,5,"Not a real error message, but a test to see if it works :-)");
printf("Stopping the server\n");
server->StopServer();
// See if the server is indeed in stopped state
printf("The server is %s\n",server->GetIsRunning() ? "still running!\n" : "stopped.\n");
// Remember for a cmd shell
nRetCode = errors;
}
else
{
totalErrors = 1;
printf("HTTPServer in error state in : Error %lu: %s\n"
,server->GetLastError()
,(LPCTSTR)GetLastErrorAsString(GetLastError()));
}
CleanupServer(server,logfile);
}
}
printf("\n");
printf("SUMMARY OF ALL SERVER TESTS\n");
printf("===========================\n");
if(totalErrors)
{
printf("ERRORS: %d\n",nRetCode += totalErrors);
}
else
{
printf("ALL OK !!!! YIPEEEE!!!!\n");
}
WaitForKey();
WaitForKey();
}
DeleteCriticalSection(&std_stream);
return nRetCode;
}
struct descriptor_xd *MdsFilter(float *in_data, float *in_dim, int *size, float *cut_off, int *num_in_poles)
{
static struct descriptor_xd out_xd = {0, DTYPE_DSC, CLASS_XD, 0, 0};
DESCRIPTOR_A(data_d, sizeof(float), DTYPE_FLOAT, 0, 0);
DESCRIPTOR_SIGNAL(signal_d, 1, 0, 0);
DESCRIPTOR_DIMENSION(dimension_d, 0, 0);
DESCRIPTOR_WINDOW(window_d, 0, 0, 0);
DESCRIPTOR_RANGE(range_d, 0, 0, 0);
struct descriptor
start_d = {sizeof(float), DTYPE_FLOAT, CLASS_S, 0},
end_d = {sizeof(float), DTYPE_FLOAT, CLASS_S, 0},
delta_d = {sizeof(float), DTYPE_FLOAT, CLASS_S, 0},
start_idx_d = {sizeof(int), DTYPE_L, CLASS_S, 0},
end_idx_d = {sizeof(int), DTYPE_L, CLASS_S, 0},
time_at_0_d = {sizeof(float), DTYPE_FLOAT, CLASS_S, 0};
int num_samples, num_poles, start_idx, end_idx, i;
float fc, delta, dummy, *filtered_data, start, end, time_at_0;
float phs_steep, delay;
float *mod, *phs;
static Filter *filter;
if(*num_in_poles > 0)
num_poles = *num_in_poles;
else
num_poles = 10;
signal_d.data = (struct descriptor *)&data_d;
signal_d.dimensions[0] = (struct descriptor *)&dimension_d;
dimension_d.window = (struct descriptor *)&window_d;
dimension_d.axis = (struct descriptor *)&range_d;
window_d.startidx = (struct descriptor *)&start_idx_d;
window_d.endingidx = (struct descriptor *)&end_idx_d;
window_d.value_at_idx0 = (struct descriptor *)&time_at_0_d;
start_idx_d.pointer = (char*)&start_idx;
end_idx_d.pointer = (char *)&end_idx;
time_at_0_d.pointer = (char *)&time_at_0;
range_d.begin = (struct descriptor *)&start_d;
range_d.ending = (struct descriptor *)&end_d;
range_d.deltaval = (struct descriptor *)&delta_d;
start_d.pointer = (char *)&start;
end_d.pointer = (char *)&end;
delta_d.pointer = (char *)δ
num_samples = *size;
fc = 1/ (in_dim[1] - in_dim[0]);
filter = ButtwInvar(cut_off, &dummy, &dummy, &dummy, &fc, &num_poles);
filtered_data = (float *)malloc(num_samples * sizeof(float));
mod = (float *)malloc(sizeof(float) * 1000);
phs = (float *)malloc(sizeof(float) * 1000);
TestFilter(filter, fc, 1000, mod, phs);
for(i = 1; i < 1000 - 1 && !isnan(phs[i]) && !isnan(phs[i+1]) && phs[i] > phs[i+1]; i++);
if(i > 1 && i < 1000)
{
phs_steep = (phs[1] - phs[i])/((i/1000.) * fc/2.);
delay = phs_steep/(2*PI);
}
free((char *)mod);
free((char *)phs);
DoFilter(filter, in_data, filtered_data, &num_samples);
FreeFilter(filter);
data_d.pointer = (char *)filtered_data;
data_d.arsize = num_samples * sizeof(float);
start = in_dim[0]-delay;
end = in_dim[num_samples - 1]-delay;
delta = in_dim[1] - in_dim[0];
start_idx = 0;
end_idx = num_samples - 1;
time_at_0 = in_dim[0] - delay;
MdsCopyDxXd((struct descriptor *)&signal_d, &out_xd);
free((char *)filtered_data);
return &out_xd;
}
bool ValidateCipherModes()
{
cout << "\nTesting DES modes...\n\n";
const byte key[] = {0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef};
const byte iv[] = {0x12,0x34,0x56,0x78,0x90,0xab,0xcd,0xef};
const byte plain[] = { // "Now is the time for all " without tailing 0
0x4e,0x6f,0x77,0x20,0x69,0x73,0x20,0x74,
0x68,0x65,0x20,0x74,0x69,0x6d,0x65,0x20,
0x66,0x6f,0x72,0x20,0x61,0x6c,0x6c,0x20};
DESEncryption desE(key);
DESDecryption desD(key);
bool pass=true, fail;
{
// from FIPS 81
const byte encrypted[] = {
0x3f, 0xa4, 0x0e, 0x8a, 0x98, 0x4d, 0x48, 0x15,
0x6a, 0x27, 0x17, 0x87, 0xab, 0x88, 0x83, 0xf9,
0x89, 0x3d, 0x51, 0xec, 0x4b, 0x56, 0x3b, 0x53};
ECB_Mode_ExternalCipher::Encryption modeE(desE);
fail = !TestFilter(StreamTransformationFilter(modeE, NULL, StreamTransformationFilter::NO_PADDING).Ref(),
plain, sizeof(plain), encrypted, sizeof(encrypted));
pass = pass && !fail;
cout << (fail ? "FAILED " : "passed ") << "ECB encryption" << endl;
ECB_Mode_ExternalCipher::Decryption modeD(desD);
fail = !TestFilter(StreamTransformationFilter(modeD, NULL, StreamTransformationFilter::NO_PADDING).Ref(),
encrypted, sizeof(encrypted), plain, sizeof(plain));
pass = pass && !fail;
cout << (fail ? "FAILED " : "passed ") << "ECB decryption" << endl;
}
{
// from FIPS 81
const byte encrypted[] = {
0xE5, 0xC7, 0xCD, 0xDE, 0x87, 0x2B, 0xF2, 0x7C,
0x43, 0xE9, 0x34, 0x00, 0x8C, 0x38, 0x9C, 0x0F,
0x68, 0x37, 0x88, 0x49, 0x9A, 0x7C, 0x05, 0xF6};
CBC_Mode_ExternalCipher::Encryption modeE(desE, iv);
fail = !TestFilter(StreamTransformationFilter(modeE, NULL, StreamTransformationFilter::NO_PADDING).Ref(),
plain, sizeof(plain), encrypted, sizeof(encrypted));
pass = pass && !fail;
cout << (fail ? "FAILED " : "passed ") << "CBC encryption with no padding" << endl;
CBC_Mode_ExternalCipher::Decryption modeD(desD, iv);
fail = !TestFilter(StreamTransformationFilter(modeD, NULL, StreamTransformationFilter::NO_PADDING).Ref(),
encrypted, sizeof(encrypted), plain, sizeof(plain));
pass = pass && !fail;
cout << (fail ? "FAILED " : "passed ") << "CBC decryption with no padding" << endl;
fail = !TestModeIV(modeE, modeD);
pass = pass && !fail;
cout << (fail ? "FAILED " : "passed ") << "CBC mode IV generation" << endl;
}
{
// generated with Crypto++, matches FIPS 81
// but has extra 8 bytes as result of padding
const byte encrypted[] = {
0xE5, 0xC7, 0xCD, 0xDE, 0x87, 0x2B, 0xF2, 0x7C,
0x43, 0xE9, 0x34, 0x00, 0x8C, 0x38, 0x9C, 0x0F,
0x68, 0x37, 0x88, 0x49, 0x9A, 0x7C, 0x05, 0xF6,
0x62, 0xC1, 0x6A, 0x27, 0xE4, 0xFC, 0xF2, 0x77};
CBC_Mode_ExternalCipher::Encryption modeE(desE, iv);
fail = !TestFilter(StreamTransformationFilter(modeE).Ref(),
plain, sizeof(plain), encrypted, sizeof(encrypted));
pass = pass && !fail;
cout << (fail ? "FAILED " : "passed ") << "CBC encryption with PKCS #7 padding" << endl;
CBC_Mode_ExternalCipher::Decryption modeD(desD, iv);
fail = !TestFilter(StreamTransformationFilter(modeD).Ref(),
encrypted, sizeof(encrypted), plain, sizeof(plain));
pass = pass && !fail;
cout << (fail ? "FAILED " : "passed ") << "CBC decryption with PKCS #7 padding" << endl;
}
{
// generated with Crypto++ 5.2, matches FIPS 81
// but has extra 8 bytes as result of padding
const byte encrypted[] = {
0xE5, 0xC7, 0xCD, 0xDE, 0x87, 0x2B, 0xF2, 0x7C,
0x43, 0xE9, 0x34, 0x00, 0x8C, 0x38, 0x9C, 0x0F,
0x68, 0x37, 0x88, 0x49, 0x9A, 0x7C, 0x05, 0xF6,
0xcf, 0xb7, 0xc7, 0x64, 0x0e, 0x7c, 0xd9, 0xa7};
CBC_Mode_ExternalCipher::Encryption modeE(desE, iv);
fail = !TestFilter(StreamTransformationFilter(modeE, NULL, StreamTransformationFilter::ONE_AND_ZEROS_PADDING).Ref(),
plain, sizeof(plain), encrypted, sizeof(encrypted));
pass = pass && !fail;
cout << (fail ? "FAILED " : "passed ") << "CBC encryption with one-and-zeros padding" << endl;
CBC_Mode_ExternalCipher::Decryption modeD(desD, iv);
fail = !TestFilter(StreamTransformationFilter(modeD, NULL, StreamTransformationFilter::ONE_AND_ZEROS_PADDING).Ref(),
encrypted, sizeof(encrypted), plain, sizeof(plain));
pass = pass && !fail;
cout << (fail ? "FAILED " : "passed ") << "CBC decryption with one-and-zeros padding" << endl;
}
{
const byte plain[] = {'a', 0, 0, 0, 0, 0, 0, 0};
// generated with Crypto++
const byte encrypted[] = {
0x9B, 0x47, 0x57, 0x59, 0xD6, 0x9C, 0xF6, 0xD0};
CBC_Mode_ExternalCipher::Encryption modeE(desE, iv);
fail = !TestFilter(StreamTransformationFilter(modeE, NULL, StreamTransformationFilter::ZEROS_PADDING).Ref(),
plain, 1, encrypted, sizeof(encrypted));
pass = pass && !fail;
cout << (fail ? "FAILED " : "passed ") << "CBC encryption with zeros padding" << endl;
CBC_Mode_ExternalCipher::Decryption modeD(desD, iv);
fail = !TestFilter(StreamTransformationFilter(modeD, NULL, StreamTransformationFilter::ZEROS_PADDING).Ref(),
encrypted, sizeof(encrypted), plain, sizeof(plain));
pass = pass && !fail;
cout << (fail ? "FAILED " : "passed ") << "CBC decryption with zeros padding" << endl;
}
{
// generated with Crypto++, matches FIPS 81
// but with last two blocks swapped as result of CTS
const byte encrypted[] = {
0xE5, 0xC7, 0xCD, 0xDE, 0x87, 0x2B, 0xF2, 0x7C,
0x68, 0x37, 0x88, 0x49, 0x9A, 0x7C, 0x05, 0xF6,
0x43, 0xE9, 0x34, 0x00, 0x8C, 0x38, 0x9C, 0x0F};
CBC_CTS_Mode_ExternalCipher::Encryption modeE(desE, iv);
fail = !TestFilter(StreamTransformationFilter(modeE).Ref(),
plain, sizeof(plain), encrypted, sizeof(encrypted));
pass = pass && !fail;
cout << (fail ? "FAILED " : "passed ") << "CBC encryption with ciphertext stealing (CTS)" << endl;
CBC_CTS_Mode_ExternalCipher::Decryption modeD(desD, iv);
fail = !TestFilter(StreamTransformationFilter(modeD).Ref(),
encrypted, sizeof(encrypted), plain, sizeof(plain));
pass = pass && !fail;
cout << (fail ? "FAILED " : "passed ") << "CBC decryption with ciphertext stealing (CTS)" << endl;
fail = !TestModeIV(modeE, modeD);
pass = pass && !fail;
cout << (fail ? "FAILED " : "passed ") << "CBC CTS IV generation" << endl;
}
{
// generated with Crypto++
const byte decryptionIV[] = {0x4D, 0xD0, 0xAC, 0x8F, 0x47, 0xCF, 0x79, 0xCE};
const byte encrypted[] = {0x12, 0x34, 0x56};
byte stolenIV[8];
CBC_CTS_Mode_ExternalCipher::Encryption modeE(desE, iv);
modeE.SetStolenIV(stolenIV);
fail = !TestFilter(StreamTransformationFilter(modeE).Ref(),
plain, 3, encrypted, sizeof(encrypted));
fail = memcmp(stolenIV, decryptionIV, 8) != 0 || fail;
pass = pass && !fail;
cout << (fail ? "FAILED " : "passed ") << "CBC encryption with ciphertext and IV stealing" << endl;
CBC_CTS_Mode_ExternalCipher::Decryption modeD(desD, stolenIV);
fail = !TestFilter(StreamTransformationFilter(modeD).Ref(),
encrypted, sizeof(encrypted), plain, 3);
pass = pass && !fail;
cout << (fail ? "FAILED " : "passed ") << "CBC decryption with ciphertext and IV stealing" << endl;
}
{
const byte encrypted[] = { // from FIPS 81
0xF3,0x09,0x62,0x49,0xC7,0xF4,0x6E,0x51,
0xA6,0x9E,0x83,0x9B,0x1A,0x92,0xF7,0x84,
0x03,0x46,0x71,0x33,0x89,0x8E,0xA6,0x22};
CFB_Mode_ExternalCipher::Encryption modeE(desE, iv);
fail = !TestFilter(StreamTransformationFilter(modeE).Ref(),
plain, sizeof(plain), encrypted, sizeof(encrypted));
pass = pass && !fail;
cout << (fail ? "FAILED " : "passed ") << "CFB encryption" << endl;
CFB_Mode_ExternalCipher::Decryption modeD(desE, iv);
fail = !TestFilter(StreamTransformationFilter(modeD).Ref(),
encrypted, sizeof(encrypted), plain, sizeof(plain));
pass = pass && !fail;
cout << (fail ? "FAILED " : "passed ") << "CFB decryption" << endl;
fail = !TestModeIV(modeE, modeD);
pass = pass && !fail;
cout << (fail ? "FAILED " : "passed ") << "CFB mode IV generation" << endl;
}
{
const byte plain[] = { // "Now is the." without tailing 0
0x4e,0x6f,0x77,0x20,0x69,0x73,0x20,0x74,0x68,0x65};
const byte encrypted[] = { // from FIPS 81
0xf3,0x1f,0xda,0x07,0x01,0x14,0x62,0xee,0x18,0x7f};
CFB_Mode_ExternalCipher::Encryption modeE(desE, iv, 1);
fail = !TestFilter(StreamTransformationFilter(modeE).Ref(),
plain, sizeof(plain), encrypted, sizeof(encrypted));
pass = pass && !fail;
cout << (fail ? "FAILED " : "passed ") << "CFB (8-bit feedback) encryption" << endl;
CFB_Mode_ExternalCipher::Decryption modeD(desE, iv, 1);
fail = !TestFilter(StreamTransformationFilter(modeD).Ref(),
encrypted, sizeof(encrypted), plain, sizeof(plain));
pass = pass && !fail;
cout << (fail ? "FAILED " : "passed ") << "CFB (8-bit feedback) decryption" << endl;
fail = !TestModeIV(modeE, modeD);
pass = pass && !fail;
cout << (fail ? "FAILED " : "passed ") << "CFB (8-bit feedback) IV generation" << endl;
}
{
const byte encrypted[] = { // from Eric Young's libdes
0xf3,0x09,0x62,0x49,0xc7,0xf4,0x6e,0x51,
0x35,0xf2,0x4a,0x24,0x2e,0xeb,0x3d,0x3f,
0x3d,0x6d,0x5b,0xe3,0x25,0x5a,0xf8,0xc3};
OFB_Mode_ExternalCipher::Encryption modeE(desE, iv);
fail = !TestFilter(StreamTransformationFilter(modeE).Ref(),
plain, sizeof(plain), encrypted, sizeof(encrypted));
pass = pass && !fail;
cout << (fail ? "FAILED " : "passed ") << "OFB encryption" << endl;
OFB_Mode_ExternalCipher::Decryption modeD(desE, iv);
fail = !TestFilter(StreamTransformationFilter(modeD).Ref(),
encrypted, sizeof(encrypted), plain, sizeof(plain));
pass = pass && !fail;
cout << (fail ? "FAILED " : "passed ") << "OFB decryption" << endl;
fail = !TestModeIV(modeE, modeD);
pass = pass && !fail;
cout << (fail ? "FAILED " : "passed ") << "OFB IV generation" << endl;
}
{
const byte encrypted[] = { // generated with Crypto++
0xF3, 0x09, 0x62, 0x49, 0xC7, 0xF4, 0x6E, 0x51,
0x16, 0x3A, 0x8C, 0xA0, 0xFF, 0xC9, 0x4C, 0x27,
0xFA, 0x2F, 0x80, 0xF4, 0x80, 0xB8, 0x6F, 0x75};
CTR_Mode_ExternalCipher::Encryption modeE(desE, iv);
fail = !TestFilter(StreamTransformationFilter(modeE).Ref(),
plain, sizeof(plain), encrypted, sizeof(encrypted));
pass = pass && !fail;
cout << (fail ? "FAILED " : "passed ") << "Counter Mode encryption" << endl;
CTR_Mode_ExternalCipher::Decryption modeD(desE, iv);
fail = !TestFilter(StreamTransformationFilter(modeD).Ref(),
encrypted, sizeof(encrypted), plain, sizeof(plain));
pass = pass && !fail;
cout << (fail ? "FAILED " : "passed ") << "Counter Mode decryption" << endl;
fail = !TestModeIV(modeE, modeD);
pass = pass && !fail;
cout << (fail ? "FAILED " : "passed ") << "Counter Mode IV generation" << endl;
}
{
const byte plain[] = { // "7654321 Now is the time for "
0x37, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31, 0x20,
0x4e, 0x6f, 0x77, 0x20, 0x69, 0x73, 0x20, 0x74,
0x68, 0x65, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20,
0x66, 0x6f, 0x72, 0x20};
const byte mac1[] = { // from FIPS 113
0xf1, 0xd3, 0x0f, 0x68, 0x49, 0x31, 0x2c, 0xa4};
const byte mac2[] = { // generated with Crypto++
0x35, 0x80, 0xC5, 0xC4, 0x6B, 0x81, 0x24, 0xE2};
CBC_MAC<DES> cbcmac(key);
HashFilter cbcmacFilter(cbcmac);
fail = !TestFilter(cbcmacFilter, plain, sizeof(plain), mac1, sizeof(mac1));
pass = pass && !fail;
cout << (fail ? "FAILED " : "passed ") << "CBC MAC" << endl;
DMAC<DES> dmac(key);
HashFilter dmacFilter(dmac);
fail = !TestFilter(dmacFilter, plain, sizeof(plain), mac2, sizeof(mac2));
pass = pass && !fail;
cout << (fail ? "FAILED " : "passed ") << "DMAC" << endl;
}
return pass;
}
bool ValidateBaseCode()
{
bool pass = true, fail;
byte data[255];
for (unsigned int i=0; i<255; i++)
data[i] = i;
const char *hexEncoded =
"000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F2021222324252627"
"28292A2B2C2D2E2F303132333435363738393A3B3C3D3E3F404142434445464748494A4B4C4D4E4F"
"505152535455565758595A5B5C5D5E5F606162636465666768696A6B6C6D6E6F7071727374757677"
"78797A7B7C7D7E7F808182838485868788898A8B8C8D8E8F909192939495969798999A9B9C9D9E9F"
"A0A1A2A3A4A5A6A7A8A9AAABACADAEAFB0B1B2B3B4B5B6B7B8B9BABBBCBDBEBFC0C1C2C3C4C5C6C7"
"C8C9CACBCCCDCECFD0D1D2D3D4D5D6D7D8D9DADBDCDDDEDFE0E1E2E3E4E5E6E7E8E9EAEBECEDEEEF"
"F0F1F2F3F4F5F6F7F8F9FAFBFCFDFE";
const char *base32Encoded =
"AAASEA2EAWDAQCAJBIFS2DIQB6IBCESVCSKTNF22DEPBYHA7D2RUAIJCENUCKJTHFAWUWK3NFWZC8NBT"
"GI3VIPJYG66DUQT5HS8V6R4AIFBEGTCFI3DWSUKKJPGE4VURKBIXEW4WKXMFQYC3MJPX2ZK8M7SGC2VD"
"NTUYN35IPFXGY5DPP3ZZA6MUQP4HK7VZRB6ZW856RX9H9AEBSKB2JBNGS8EIVCWMTUG27D6SUGJJHFEX"
"U4M3TGN4VQQJ5HW9WCS4FI7EWYVKRKFJXKX43MPQX82MDNXVYU45PP72ZG7MZRF7Z496BSQC2RCNMTYH"
"3DE6XU8N3ZHN9WGT4MJ7JXQY49NPVYY55VQ77Z9A6HTQH3HF65V8T4RK7RYQ55ZR8D29F69W8Z5RR8H3"
"9M7939R8";
const char *base64AndHexEncoded =
"41414543417751464267634943516F4C4441304F4478415245684D554652595847426B6147787764"
"486838674953496A4A43556D4A7967704B6973734C5334764D4445794D7A51310A4E6A63344F546F"
"375044302B50304242516B4E4552555A4853456C4B5330784E546B395155564A5456465657563168"
"5A576C746358563566594746695932526C5A6D646F615770720A6247317562334278636E4E306458"
"5A3365486C3665337839666E2B4167594B44684957476834694A696F754D6A5936506B4A47536B35"
"53566C7065596D5A71626E4A32656E3643680A6F714F6B7061616E714B6D717136797472712B7773"
"624B7A744C573274376935757275387662362F774D484377385446787366497963724C7A4D334F7A"
"39445230745055316462580A324E6E6132397A6433742F6734654C6A354F586D352B6A7036757673"
"3765377638504879382F5431397666342B6672372F50332B0A";
cout << "\nBase64, base32 and hex coding validation suite running...\n\n";
fail = !TestFilter(HexEncoder().Ref(), data, 255, (const byte *)hexEncoded, strlen(hexEncoded));
cout << (fail ? "FAILED " : "passed ");
cout << "Hex Encoding\n";
pass = pass && !fail;
fail = !TestFilter(HexDecoder().Ref(), (const byte *)hexEncoded, strlen(hexEncoded), data, 255);
cout << (fail ? "FAILED " : "passed ");
cout << "Hex Decoding\n";
pass = pass && !fail;
fail = !TestFilter(Base32Encoder().Ref(), data, 255, (const byte *)base32Encoded, strlen(base32Encoded));
cout << (fail ? "FAILED " : "passed ");
cout << "Base32 Encoding\n";
pass = pass && !fail;
fail = !TestFilter(Base32Decoder().Ref(), (const byte *)base32Encoded, strlen(base32Encoded), data, 255);
cout << (fail ? "FAILED " : "passed ");
cout << "Base32 Decoding\n";
pass = pass && !fail;
fail = !TestFilter(Base64Encoder(new HexEncoder).Ref(), data, 255, (const byte *)base64AndHexEncoded, strlen(base64AndHexEncoded));
cout << (fail ? "FAILED " : "passed ");
cout << "Base64 Encoding\n";
pass = pass && !fail;
fail = !TestFilter(HexDecoder(new Base64Decoder).Ref(), (const byte *)base64AndHexEncoded, strlen(base64AndHexEncoded), data, 255);
cout << (fail ? "FAILED " : "passed ");
cout << "Base64 Decoding\n";
pass = pass && !fail;
return pass;
}
