5598 lines
238 KiB
C++
5598 lines
238 KiB
C++
// Copyright (c) 2013-2015 IONU Security, Inc. All rights reserved.
|
||
//
|
||
// Command line test program for libeye C++ and C interfaces
|
||
|
||
#include <cstdio>
|
||
#include <cstring>
|
||
#include <sys/stat.h>
|
||
|
||
#include <algorithm>
|
||
#include <chrono>
|
||
#include <map>
|
||
#include <string>
|
||
|
||
#include <openssl/err.h>
|
||
#include <openssl/ssl.h>
|
||
#include <openssl/rand.h>
|
||
#include <openssl/ec.h>
|
||
#include <openssl/rsa.h>
|
||
|
||
//#include "eyeball.h"
|
||
//#include "eyecontainer.h"
|
||
#include "eyeencrypteddb.h"
|
||
//#include "eyedirectory.h"
|
||
#include "eyedrbg.h"
|
||
#include "eyeinterface.h"
|
||
#include "eyejson.h"
|
||
#include "eyelock.h"
|
||
#include "eyelog.h"
|
||
//#include "eyeconnection.h"
|
||
#include "eyering.h"
|
||
#ifdef ALAN
|
||
#include "eyesearch.h"
|
||
#include "eyestemmer.h"
|
||
#endif
|
||
//#include "eyestream.h"
|
||
#include "eyetime.h"
|
||
#include "eyeutils.h"
|
||
|
||
long ms; // System time in milliseconds
|
||
const char* shortword = "Hi";
|
||
const char* password = "u3K2*l$qZ0a<";
|
||
static const char* passwordset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ01234567890";
|
||
unsigned char garbage[SL_AES_KEY_LEN];
|
||
static const char* longtest = "test/thisisaverylongtestpathfortarformatcheckingandverificationpurposes_exceedstar1988maxpath/verylongpathtartest.txt";
|
||
static const char* testfile = "test/tartest.txt";
|
||
static const char* testfile_orig = "test/tartest.orig";
|
||
static const char* attachfile = "test/attachment.docx";
|
||
static const char* thumbfile = "test/thumb.png";
|
||
static const char* xmlfile = "test/test.xsd";
|
||
static const char* htmlfile = "test/test.html";
|
||
static const char* jsonfile = "test/test.json";
|
||
static const char* njsonfile = "test/nothere.json";
|
||
static const char* cionu = "test/ctest.ionu";
|
||
static const char* oldionu = "test/old.ionu";
|
||
static const char* yoionu = "test/yotest.ionu";
|
||
// Modified .iks files
|
||
static const char* empty_iks = "test/empty.iks";
|
||
|
||
// Modified .ionu files
|
||
static const char* empty_ionu = "test/empty.ionu";
|
||
static const char* perm_mods = "test/perm_mods.ionu";
|
||
static const char* meta_corrupt = "test/meta_corrupt.ionu";
|
||
static const char* fek_corrupt = "test/badfek1.ionu";
|
||
static const char* chksum_corrupt = "test/badchksum.ionu";
|
||
|
||
static const char* keystore = "test/keystore.iks";
|
||
static const unsigned char TestKey[SL_AES_KEY_LEN] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31};
|
||
//static const unsigned char TGIkey[SL_AES_KEY_LEN] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31};
|
||
static const unsigned char badkey[SL_AES_KEY_LEN] = {1,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31};
|
||
static const unsigned char utf8[10] = {0x24, 0xc2,0xa2, 0xe2,0x82,0xac, 0xf0,0xa4,0xad,0xa2};
|
||
static const char* smiley = "SMILING FACE WITH OPEN MOUTH AND SMILING EYES \\uD83D\\uDE04";
|
||
static const char* utfjson = "\\u0123\\u4567\\u89AB\\uCDEF\\uabcd\\uef4A ";
|
||
static const char* utfeuro = "euro \\u20ac cent \\u00a2";
|
||
|
||
static const char* URN = "urn:sl:FFFFFF:FFFFFFFF:FFFF:FFFFFFFFFFFF";
|
||
static const char* URN0 = "urn:sl:000000:00000000:FFFF:D2F04FEB8495";
|
||
static const char* URN1 = "urn:sl:000000:00000000:FFFF:";
|
||
static const char* URN2 = "urn:sl:000100:00000100::000000000ED2";
|
||
static const char* URN3 = "urn:sl:000101:00001000::";
|
||
static const char* URN4 = "urn:sl:001001:::";
|
||
static const char* URN5 = "urn:sl::::";
|
||
static const char* officeURN = "urn:sl:000000:12345678:::";
|
||
static const char* docURN = "urn:sl:000000:12345678:ABCD:0123456789AB";
|
||
static const char* burn0 = "urn:sl:000001:00000010:7fFf:000000000EG2"; // Bad digit
|
||
static const char* burn1 = "urn:sl:000001:7fffffff:0A00"; // Missing field
|
||
static const char* burn2 = "urn:sl:000001:00000010:0A00:000000000ED2:00"; // extra field
|
||
static const char* burn3 = "urn:sl:1ffffff:fFfFfF:FfFf:000000000ED2"; // Too large van
|
||
static const char* burn4 = "urn:sl:0:1fffFfFfF:FfFf:000000000ED2"; // Too large pmo
|
||
static const char* burn5 = "urn:sl:0:fFfFfF:1FfFf:000000000ED2"; // Too large device
|
||
static const char* burn6 = "urn:sl:ffffff:fffFfFfF:FfFf:1ffffffffffff"; // Too large device
|
||
static const char* burn7 = "urn:ion:002:1ffffff:0A00:000000000ED2"; // Invalid ionu
|
||
static const char* shredurn = "urn:sl:000011:00000010:0ABC:00000000DED2";
|
||
//static const char* challenges = "[{\"me\":\"urn:sl:000001:00000010::\"},{\"tim\":\"urn:sl:000011:00000010::\"}]";
|
||
#ifndef WIN32
|
||
static const std::vector<std::string> challengeQuestions = {"favbook", "flame", "kiss", "kissloc", "concert", "memperson",
|
||
"favchar", "favsay", "neverinv", "bestcostume", "growndiff", "wallpic", "childnames", "songdesc", "erasure", "custom"};
|
||
static const std::vector<std::string> challengeAnswers = {"HARRYPOTTER", "LUANN", "LAURIE", "TRUCK", "BTO", "EDISON",
|
||
"NIKITA", "HAVEYOUFIGUREDITOUT", "OBAMA", "BUNNY", "FLINTSTONE", "RANDOM", "JACK", "HMMMMMM", "ARNOLD", "MYQUESTION"};
|
||
#endif
|
||
static const char* challenges = "[\"IOnU\",\"favchar::BOULDER\",\"celebrity::UNIT TEST\",\"custom:UNIT:TESTING\"]";
|
||
static const char* challenges1 = "[\"IOnU\",\"favchar::LARAMIE\",\"celebrity::UNIT TEST\",\"custom:UNIT:TESTING\"]";
|
||
static const char* challenges2 = "[\"IOnU\",\"favchar::DUBLIN\",\"celebrity::BONO\",\"custom:FAVORITE BIKE:BMW\"]";
|
||
static const char* challenges3 = "[\"IOnU\",\"favchar::RENO\",\"celebrity::HARAH\",\"custom:FAVORITEBIKE:YAMAHAH\"]";
|
||
static const char* challenges4 = "[\"IOnU\",\"favchar::NEWYORK\",\"celebrity::BLOOMBERG\",\"custom:FAVORITEBIKE:TREK\"]";
|
||
static const char* challenges5 = "[\"IOnU\",\"favchar::WASHINGTONDC\",\"celebrity::BOND\",\"custom:FAVORITEBIKE:DUCATI\"]";
|
||
static const char* challenges6 = "[\"IOnU\",\"favchar::CUPERTINO\",\"celebrity::SHIVA\",\"custom:FAVORITEBIKE:CERVELO\"]";
|
||
static const char* challenges7 = "[\"IOnU\",\"favchar::CHEYENNE\",\"celebrity::TOBYKEITH\",\"custom:FAVORITEBIKE:SUZUKI\"]";
|
||
static const char* challenges8 = "[\"IOnU\",\"BOB\",\"SMITH\",\"NIKKI\"]";
|
||
static const char* challenges9 = "[\"IOnU\",\"one\",\"two\",\"three\"]";
|
||
static const char* challenges10 = "[\"IOnU\",\"one\",\"one\",\"one\"]";
|
||
static const char* challenges11 = "[\"one\",\"two\",\"three\"]";
|
||
static const char* challenges12 = "[\"IOnU\",\"favbook::ONE\",\"flame::TWO\",\"kiss::THREE\"]";
|
||
static const char* shortchallenge = "[\"IOnU\"]";
|
||
static const char* supershortchallenge = "onetwothree";
|
||
static const char* members = "[{\"me\":\"urn:sl:000001:00000010::\"},{\"tim\":\"urn:sl:000011:00000010::\"}]";
|
||
static const char* cgurl = "/cgsl/v2/office/discover?email=freddy&password=6EVdXfSkSX%2bI15ZXGCRRH4TnpBnt17ivih5Nd7DxkPQ%3d&\
|
||
vanURN=urn%3aionu%3a000000%3a%3a%3a&deviceURN=urn%3aionu%3a000000%3aEB3AFD45%3a4239%3a";
|
||
|
||
static const char* badMeta = "\
|
||
{platform=OSX, utime=2014-04-26T17:23:19.996Z, status=modified, contents=[{\"md5\":\"b2ab1008fefd005d9ade42e3d63205ff\",\
|
||
\"metatype\":\"msg\",\"mimetype\":\"text/plain\",\"time\":\"2014-04-26T17:23:17Z\",\"size\":8},\
|
||
{\"md5\":\"30ed0df9f4203931f8a539c0fcd6539c\",\"metatype\":\"file\",\"mimetype\":\"image/jpeg\",\
|
||
\"time\":\"2014-04-26T17:23:17Z\",\"size\":131118}], modified_date=2014-04-26T17:23:17.221Z, \
|
||
mtime=2014-04-26T17:24:12.838Z, file_operations={\"vanished_on\":{\"urn:sl:000000:67D77BB4::\":\"2014-04-26T17:24:05.983Z\"}},\
|
||
digest=sha256, ver=0.1, drr=true, tgisig=656930478659, urn=urn:sl:000000:A606592D:0F47:9F496CEBE3AF, \
|
||
burn_date=2014-04-26T17:24:05.883Z, magic=IOnU Encrypted Archive, expires=2014-04-26T17:24:05.899Z, sync=false, tctr=18, \
|
||
modified_by=urn:sl:000000:A606592D:0F47:, action=VANISH, rr=[\"urn:sl:000000:67D77BB4::\"], seq=3, cipher=aes256cbc, tbr=true, rrr=true}";
|
||
|
||
static const char* vanishMeta = "\
|
||
{\"platform\":\"OSX\",\"utime\":\"2014-04-26T17:23:19.996Z\",\"status\":\"modified\",\"contents\":[{\"md5\":\"b2ab1008fefd005d9ade42e3d63205ff\",\
|
||
\"metatype\":\"msg\",\"mimetype\":\"text/plain\",\"time\":\"2014-04-26T17:23:17Z\",\"size\":8},{\"md5\":\"30ed0df9f4203931f8a539c0fcd6539c\",\
|
||
\"metatype\":\"file\",\"mimetype\":\"image/jpeg\",\"time\":\"2014-04-26T17:23:17Z\",\"size\":131118}],\"modified_date\":\"2014-04-26T17:23:17.221Z\",\
|
||
\"mtime\":\"2014-04-26T17:24:12.838Z\",\"file_operations\":{\"vanished_on\":{\"urn:sl:000000:67D77BB4::\":\"2014-04-26T17:24:05.983Z\"}},\
|
||
\"digest\":\"sha256\",\"ver\":\"0.1\",\"drr\":true,\"tgisig\":\"656930478659\",\"urn\":\"urn:sl:000000:A606592D:0F47:9F496CEBE3AF\",\
|
||
\"burn_date\":\"2014-04-26T17:24:05.883Z\",\"magic\":\"IOnU Encrypted Archive\",\"expires\":\"2014-04-26T17:24:05.899Z\",\"sync\":false,\
|
||
\"tctr\":16,\"modified_by\":\"urn:sl:000000:A606592D:0F47:\",\"action\":\"VANISH\",\"rr\":[\"urn:sl:000000:67D77BB4::\"],\"seq\":3,\
|
||
\"cipher\":\"aes256cbc\",\"tbr\":true,\"rrr\":true}";
|
||
|
||
static const char* uploadedMeta = "\
|
||
{\"magic\":\"IOnU Encrypted Archive\",\"tgisig\":\"64f2a81d678c\",\"urn\":\"urn:sl:000000:17C38E5A:C60D:79916D07C42C\",\
|
||
\"modified_by\":\"urn:sl:000000:17C38E5A:C60D:\",\"drr\":true,\"contents\":[{\"time\":\"2014-01-02T16:56:29Z\",\
|
||
\"mimetype\":\"text/plain\",\"size\":2,\"metatype\":\"msg\",\"md5\":\"23b58def11b45727d3351702515f86af\"},\
|
||
{\"time\":\"2014-01-02T16:56:29Z\",\"mimetype\":\"image\\/jpeg\",\"size\":565679,\"metatype\":\"file\",\
|
||
\"md5\":\"fa802d84e9618dc23b5dbaaa17e31a8d\"}],\"platform\":\"OSX\",\"seq\":2,\"tctr\":5,\"rr\":[\"\"],\
|
||
\"utime\":\"2014-01-02T16:56:31.308Z\",\"ver\":\"0.1\",\"synchronized_date\":\"2014-01-02T16:57:59.333Z\",\
|
||
\"modified_date\":\"2014-01-02T16:56:30.274Z\",\"cipher\":\"aes256cbc\",\"digest\":\"sha256\",\
|
||
\"status\":\"modified\",\"mtime\":\"2014-01-02T16:57:57.851Z\"}";
|
||
|
||
static const char* someMeta = "\
|
||
{\"utime\":\"2014-04-22T16:01:43.765Z\",\"platform\":\"Windows\",\"status\":\"modified\",\"modified_date\":\"2014-04-22T16:01:41.629Z\",\
|
||
\"contents\":[{\"md5\":\"9b5c5c35567fc20ad7f305014cddfcd0\",\"metatype\":\"msg\",\"mimetype\":\"text\\/plain\",\"time\":\"2014-04-22T16:01:41Z\",\
|
||
\"size\":3}],\"mtime\":\"2014-04-28T22:05:25.481Z\",\"digest\":\"sha256\",\"ver\":\"0.1\",\"drr\":true,\"tgisig\":\"16dadd9cb2ac\",\
|
||
\"urn\":\"urn:sl:000000:6BBC3A33:F9CB:6F3AE7A6CBA3\",\"magic\":\"IOnU Encrypted Archive\",\"sync\":false,\"tctr\":5,\
|
||
\"modified_by\":\"urn:sl:000000:6BBC3A33:F9CB:\",\"seq\":2,\"rr\":[\"\"],\"action\":\"DELETE\",\"cipher\":\"aes256cbc\",\"tbr\":false,\"rrr\":true,\"dr\":[\"\"]}";
|
||
|
||
static const char* updateMeta = "\
|
||
{\"modified_by\":\"urn:sl:Alan00:17C38E5A:C60D:\",\"drr\":true}";
|
||
|
||
static const char* operationsMeta = "\
|
||
{\"file_operations\":\
|
||
\"deleted_by\":{\
|
||
\"urn:sl:000000:4616E326::\":\"2014-01-07T20:15:25.543Z\",\
|
||
\"urn:sl:000000:6B424AA9::\":\"2014-01-07T07:33:11.228Z\"\
|
||
},\
|
||
\"vanished_on\":{\
|
||
\"urn:sl:000000:6B424AA9::\":\"2014-01-06T23:12:18.155Z\"\
|
||
}\
|
||
}";
|
||
|
||
static const char* megaMeta = "\
|
||
{\"ver\":\"0.1\",\"magic\":\"IOnU Encrypted Archive\",\"status\":\"modified\",\"tctr\":0,\"urn\":\"urn:ion\
|
||
u:000001:00000010:0011:00000000ffff\",\"cipher\":\"aes256cbc\",\"digest\":\"sha256\",\"tgi\
|
||
sig\":\"6a0ce1ec504b\",\"contents\":[{\"metatype\":\"msg\",\"mimetype\":\"text/plain\",\"size\"\
|
||
:11,\"time\":\"2013-08-08T20:56:57Z\"},{\"metatype\":\"file\",\"mimetype\":\"application/vn\
|
||
d.ms-word\",\"size\":20721,\"time\":\"2013-08-01T23:34:29Z\"},{\"metatype\":\"thumb\",\"mime\
|
||
type\":\"image/png\",\"size\":45119,\"time\":\"2013-08-01T23:34:29Z\"},{\"metatype\":\"msg\",\
|
||
\"mimetype\":\"text/plain\",\"size\":14,\"time\":\"2013-08-08T20:56:57Z\"}]}";
|
||
static const char* tgiMeta = "\
|
||
{\"ver\":\"0.1\",\"magic\":\"IOnU Encrypted Archive\",\"status\":\"modified\",\"tctr\":0,\"urn\":\"urn:ion\
|
||
u:000001:00000010:0011:00000000ffff\",\"cipher\":\"aes256cbc\",\"digest\":\"sha256\",\"tgi\
|
||
sig\":\"6b0ce1ec504b\",\"contents\":[{\"metatype\":\"msg\",\"mimetype\":\"text/plain\",\"size\"\
|
||
:11,\"time\":\"2013-08-08T20:56:57Z\"},{\"metatype\":\"file\",\"mimetype\":\"application/vn\
|
||
d.ms-word\",\"size\":20721,\"time\":\"2013-08-01T23:34:29Z\"},{\"metatype\":\"thumb\",\"mime\
|
||
type\":\"image/png\",\"size\":45119,\"time\":\"2013-08-01T23:34:29Z\"},{\"metatype\":\"msg\",\
|
||
\"mimetype\":\"text/plain\",\"size\":14,\"time\":\"2013-08-08T20:56:57Z\"}]}";
|
||
|
||
//static const char* members = "[\"urn:sl:000001:00000010::\",\"urn:sl:000011:00000010::\"]";
|
||
static const char* collabs = "{\"collab\":[{\"publicKey\":\"\
|
||
-----BEGIN PUBLIC KEY-----\n\
|
||
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAzBTVhKef/68WvTns382x\n\
|
||
Pw9i4RvZX3y8DH70YEvP3WgqC39pD3PLhe7RiRvEGHWm0cdVpvUg1rdUE1pVPNSZ\n\
|
||
jan/I8YUuX9eqLDZf6iqCYm5KwLjreaz2T0QBaKCs98I2W5qULbzKhqtw3Yp9gOy\n\
|
||
ZTlEbgkg0ZVunzLr42se0LsvmbWlEr3UksyzAJfsE6q0eKjyvpaoAFT1nTEr84Ir\n\
|
||
ZqUdn2YKV80WX9zj7maQqWviDKowxK8NKO50oCouTXNDpxwYKqoT9/8rcpOUSXaw\n\
|
||
BDbcNZWHKvG8e8icxLQqpDT3Egdnz+VtQXRwk1Yuyt8eE9jgh5dmBoo7PspQt6EV\n\
|
||
vwIDAQAB\n\
|
||
-----END PUBLIC KEY-----\
|
||
\",\"_id\":\"urn:sl:000001:00000010::\"},\
|
||
{\"publicKey\":\"\
|
||
-----BEGIN PUBLIC KEY-----\n\
|
||
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAzBTVhKef/68WvTns382x\n\
|
||
Pw9i4RvZX3y8DH70YEvP3WgqC39pD3PLhe7RiRvEGHWm0cdVpvUg1rdUE1pVPNSZ\n\
|
||
jan/I8YUuX9eqLDZf6iqCYm5KwLjreaz2T0QBaKCs98I2W5qULbzKhqtw3Yp9gOy\n\
|
||
ZTlEbgkg0ZVunzLr42se0LsvmbWlEr3UksyzAJfsE6q0eKjyvpaoAFT1nTEr84Ir\n\
|
||
ZqUdn2YKV80WX9zj7maQqWviDKowxK8NKO50oCouTXNDpxwYKqoT9/8rcpOUSXaw\n\
|
||
BDbcNZWHKvG8e8icxLQqpDT3Egdnz+VtQXRwk1Yuyt8eE9jgh5dmBoo7PspQt6EV\n\
|
||
vwIDAQAB\n\
|
||
-----END PUBLIC KEY-----\
|
||
\",\"_id\":\"urn:sl:000011:00000010::\"}]}";
|
||
static const char* PERMS = "{\"read\":[\"00000003\"],\"readAssign\":[\"00000003\"],\"write\":[\"00000003\"],\"writeAssign\":[\"00000003\"],\"admin\":[\"00000003\"],\"adminAssign\":[\"00000003\"],\"stream\":[],\"streamAssign\":[],\"doorway\":[],\"doorwayAssign\":[],\"owner\":\"00000003\"}";
|
||
static const char* PERMS2 = "{\"read\":[\"00000003\",\"00000077\"],\"readAssign\":[\"00000003\"],\"write\":[\"00000003\"],\"writeAssign\":[\"00000003\"],\"admin\":[\"00000003\"],\"adminAssign\":[\"00000003\"],\"stream\":[],\"streamAssign\":[],\"doorway\":[],\"doorwayAssign\":[],\"owner\":\"00000003\"}";
|
||
static const char* PERMS3 = "{\"read\":[\"00000003\",\"17C38E5A\"],\"adminAssign\":[\"00000003\",\"17C38E5A\"],\"admin\":[\"00000003\",\"17C38E5A\"],\"writeAssign\":[\"00000003\",\"17C38E5A\"],\"hideAssign\":[\"00000003\",\"17C38E5A\"],\"stream\":[],\"readAssign\":[\"00000003\",\"17C38E5A\"],\"owner\":\"00000003\",\"doorwayAssign\":[],\"write\":[\"00000003\",\"17C38E5A\"],\"doorway\":[],\"hide\":[],\"streamAssign\":[]}";
|
||
static const char* TopicPerms = "{\"read\":[\"123456AB\",\"123456CD\"],\"write\":[\"123456AB\"],\"admin\":[],\"doorway\":[],\"stream\":[],\"hide\":[],\"readAssign\":[\"123456AB\"],\"writeAssign\":[\"123456AB\"],\"adminAssign\":[],\"doorwayAssign\":[],\"streamAssign\":[],\"hideAssign\":[\"123456AB\"],\"topic\":\"A456BA456BA456B\"}";
|
||
|
||
static const char* policyTest = "{ \"_id\" : \"urn:sl:000000:::\", \"name\" : \"TEST VAN\", \"statusPassphrase\" : \"madman\", \"tokenPassphrase\" : \"madman\", \"policies\": [\
|
||
{\"policyName\": \"allowUserPasswordChange\", \"policyType\": \"BOOLEAN\", \"mayDelegateToAdminUsers\": true, \"mayDelegateToNormalUsers\": false, \"mayAdministerViaRemoteApp\": true, \"policyValue\": true},\
|
||
{\"policyName\": \"allowUserPasswordReset\", \"policyType\": \"BOOLEAN\", \"mayDelegateToAdminUsers\": true, \"mayDelegateToNormalUsers\": false, \"mayAdministerViaRemoteApp\": true, \"policyValue\": false},\
|
||
{\"policyName\": \"cachedTGIKeysExpire\", \"policyType\": \"duration\", \"mayDelegateToAdminUsers\": true, \"mayDelegateToNormalUsers\": false, \"mayAdministerViaRemoteApp\": true, \"policyValue\": 86400000},\
|
||
{\"policyName\": \"duration\", \"policyType\": \"BOOLEAN\", \"mayDelegateToAdminUsers\": true, \"mayDelegateToNormalUsers\": false, \"mayAdministerViaRemoteApp\": true, \"policyValue\": 1.5552E7},\
|
||
{\"policyName\": \"percentage\", \"policyType\": \"BOOLEAN\", \"mayDelegateToAdminUsers\": true, \"mayDelegateToNormalUsers\": false, \"mayAdministerViaRemoteApp\": true, \"policyValue\": 99.9}]}";
|
||
static const char *JSON = "{\"van\":{\"_id\":\"urn:sl:000000:::\",\"name\":\"TEST VAN\",\"vanPublic\":\"-----BEGIN PUBLIC KEY-----\nMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDIU1QyiN2QJbW2WUrgsvjr/OG+\ner79aVxCyXaZsdTamiOTCfw/UKm9Eg+I8IGPa9HD81wFPkN2RZYj6P4AiehaUqR4\natc+QoxmcTfv93gIVW2zkgZOn6bWk+XAw7I7qrfFM1UAEGQlDJZX+bQaxCXOBB36\n+Ba/HF3uCWqTS3OwowIDAQAB\n-----END PUBLIC KEY-----\n\",\"policies\":[{\"name\":\"challengeResponseMinLength\",\"value\":3},{\"name\":\"passwordMinLength\",\"value\":6},{\"name\":\"passphraseMinLength\",\"value\":20},{\"name\":\"customChallengeMinLength\",\"value\":6},{\"name\":\"minNumberChallengesIncludingPassword\",\"value\":4},{\"name\":\"customChallengeRequired\",\"value\":true},{\"name\":\"passwordDigitRequired\",\"value\":true},{\"name\":\"passwordAlphaRequired\",\"value\":true}]},\"cg\":\"-----BEGIN PUBLIC KEY-----\nMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDQ+S2gq98BLf43PvjF6KGnJRJA\nrhGK0YHjvYR5X53WdGG5jnzWo5Lq2JlbKNB4LxQVnPNot7wsPl1+FLAxKtGNY6Ep\nwaVasmK2aS8GX/j0BPHTXbwdVirE4EIiIPFMSv+V73phJdc4rKld66JC7EHpGI/u\ntm3qERRXtu5x6g9Q3wIDAQAB\n-----END PUBLIC KEY-----\n\",\"devices\":[{\"publicKey\":\"-----BEGIN PUBLIC KEY-----\nMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDXYZysxVvPCOLSMrOKbmefyZ7u\nAhEYCRb/jbBTDS7wsgfmWsBuc2i5oTu19sylqrk5SCFJtSiAQXM3k2N9l7+RJcoE\nsUkCgUK5LVmN+0xgqQAEZfttBIflwhqQEUROMxRBfKso5n2inAriMB/QoRntqAv4\nVe1mkrzlBa4GifU5cwIDAQAB\n-----END PUBLIC KEY-----\n\",\"enabled\":true,\"privateKey\":\"-----BEGIN RSA PRIVATE KEY-----\nMIICXQIBAAKBgQDXYZysxVvPCOLSMrOKbmefyZ7uAhEYCRb/jbBTDS7wsgfmWsBu\nc2i5oTu19sylqrk5SCFJtSiAQXM3k2N9l7+RJcoEsUkCgUK5LVmN+0xgqQAEZftt\nBIflwhqQEUROMxRBfKso5n2inAriMB/QoRntqAv4Ve1mkrzlBa4GifU5cwIDAQAB\nAoGAA4GwVlPEQeOoJbnzmF5hy4Ux1DguZRDI0hJRe5isWfjcDhEOLv4sB1GrsjO5\ncz0LVPZqrFOJvETUhmQc64+L695mhhEjLzx60DWr7Cj/ieerT+POgDXX3oOAgy/t\nNNSvn5dem/9UX7/bLSGTFPsazfiG9amfMRmYnuS3OADTf7ECQQDxQT3a3IhRYLcG\nskKC5su2OoU9klhHOYWD3WZh+O16Zfw5Yt5mP3m7RJz/L4hgOl1FUDQSom+ZiC0G\nay/TjjcpAkEA5IuLLXTI9odkKfsRqtpy1D+5bl/1tOPDe6dIxQh/N7tmX8kK73qa\nEUHVr5Fg68BbCvAGV7itXgqdSOQiwgnLOwJAQwFVxqWdjsyHyOpVormrNo+GVhWB\nQzbsqDUjrG5QtsAAj4ewMUHL84EZAZ8YB3HuWcPu0oYe7MtvherbO6yyEQJBANNB\nVeYvtG+FWQYhKQSYJlqhiONI2lNZ0eGkEPToVMgMdqYFrREOcAmRpFdEd6WTydRD\naGl/sOljwF2XW7Wm3e8CQQDCN21k+m2lwY55NPhxVCBgdl7ZCCK4RauQXyO/7a9X\nreGjb5dFQTb88P8kAwSuycc5DfHNFgU2Uv7nnSRayfLJ\n-----END RSA PRIVATE KEY-----\n\",\"_id\":\"urn:sl:000000:00000004:D1EA:\",\"description\":\"\",\"name\":\"JMeter\",\"type\":\"SNT_PEER\",\"metaType\":\"default\",\"info\":{}}],\"pmo\":{\"publicKey\":\"-----BEGIN PUBLIC KEY-----\nMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDXYZysxVvPCOLSMrOKbmefyZ7u\nAhEYCRb/jbBTDS7wsgfmWsBuc2i5oTu19sylqrk5SCFJtSiAQXM3k2N9l7+RJcoE\nsUkCgUK5LVmN+0xgqQAEZfttBIflwhqQEUROMxRBfKso5n2inAriMB/QoRntqAv4\nVe1mkrzlBa4GifU5cwIDAQAB\n-----END PUBLIC KEY-----\n\",\"enabled\":true,\"cr\":[\"password::e38ad214943daad1d64c102faec29de4afe9da3d\",\"favchar::boulder\",\"favsay::bob\",\"custom:WHO LET THE DOGS OUT:WHO WHO\"],\"phone\":{\"primary\":\"\"},\"privateKey\":\"-----BEGIN RSA PRIVATE KEY-----\nMIICXQIBAAKBgQDXYZysxVvPCOLSMrOKbmefyZ7uAhEYCRb/jbBTDS7wsgfmWsBu\nc2i5oTu19sylqrk5SCFJtSiAQXM3k2N9l7+RJcoEsUkCgUK5LVmN+0xgqQAEZftt\nBIflwhqQEUROMxRBfKso5n2inAriMB/QoRntqAv4Ve1mkrzlBa4GifU5cwIDAQAB\nAoGAA4GwVlPEQeOoJbnzmF5hy4Ux1DguZRDI0hJRe5isWfjcDhEOLv4sB1GrsjO5\ncz0LVPZqrFOJvETUhmQc64+L695mhhEjLzx60DWr7Cj/ieerT+POgDXX3oOAgy/t\nNNSvn5dem/9UX7/bLSGTFPsazfiG9amfMRmYnuS3OADTf7ECQQDxQT3a3IhRYLcG\nskKC5su2OoU9klhHOYWD3WZh+O16Zfw5Yt5mP3m7RJz/L4hgOl1FUDQSom+ZiC0G\nay/TjjcpAkEA5IuLLXTI9odkKfsRqtpy1D+5bl/1tOPDe6dIxQh/N7tmX8kK73qa\nEUHVr5Fg68BbCvAGV7itXgqdSOQiwgnLOwJAQwFVxqWdjsyHyOpVormrNo+GVhWB\nQzbsqDUjrG5QtsAAj4ewMUHL84EZAZ8YB3HuWcPu0oYe7MtvherbO6yyEQJBANNB\nVeYvtG+FWQYhKQSYJlqhiONI2lNZ0eGkEPToVMgMdqYFrREOcAmRpFdEd6WTydRD\naGl/sOljwF2XW7Wm3e8CQQDCN21k+m2lwY55NPhxVCBgdl7ZCCK4RauQXyO/7a9X\nreGjb5dFQTb88P8kAwSuycc5DfHNFgU2Uv7nnSRayfLJ\n-----END RSA PRIVATE KEY-----\n\",\"_id\":\"urn:sl:000000:00000004::\",\"email\":\"jmeter@sequencelogic.net\",\"user\":\"jmeter\",\"fullname\":\"JMeter User\"}}";
|
||
|
||
static const char* RSA_private = "-----BEGIN RSA PRIVATE KEY-----\n\
|
||
MIIEpAIBAAKCAQEAzBTVhKef/68WvTns382xPw9i4RvZX3y8DH70YEvP3WgqC39p\n\
|
||
D3PLhe7RiRvEGHWm0cdVpvUg1rdUE1pVPNSZjan/I8YUuX9eqLDZf6iqCYm5KwLj\n\
|
||
reaz2T0QBaKCs98I2W5qULbzKhqtw3Yp9gOyZTlEbgkg0ZVunzLr42se0LsvmbWl\n\
|
||
Er3UksyzAJfsE6q0eKjyvpaoAFT1nTEr84IrZqUdn2YKV80WX9zj7maQqWviDKow\n\
|
||
xK8NKO50oCouTXNDpxwYKqoT9/8rcpOUSXawBDbcNZWHKvG8e8icxLQqpDT3Egdn\n\
|
||
z+VtQXRwk1Yuyt8eE9jgh5dmBoo7PspQt6EVvwIDAQABAoIBAHkr5Zrd7CHj05yG\n\
|
||
yB4aAyNt/0epQWdwqDbDKlYCrWjIcC5jd/20wyLCqaa+1a+wK1xi/ngjE1xpfYIA\n\
|
||
IJv9ny59wP98nNGGzq1aU8l4W31OSKNBE+4tDJvvpZOy6efihV6UMIu8FKTrMkDb\n\
|
||
6A4qI8H2PqsWwGWwU/4yPdzJvYIwkjUDayCfOYjLjYJgiDK4ZrSkH6nwlTQ0ajaP\n\
|
||
gyLZrJu8o7KOa6bmyjT4iXUsvXsh5Q37rzLQd7sUOXCRvLp6QdPWvAy9zGDDew3q\n\
|
||
3ecA+87h1WDWVhnEUZl+pNKtBHRo9THUTIh3lG0eZNVPj+RLXLN8nARDauZb6cSy\n\
|
||
h35jQAECgYEA8exV7ssnhVlN8VZF/NN0FI+RX7fSTXcvVjtzQXsq8dm4vNj6VYde\n\
|
||
5gsgYSar3L0hdROFBP6E6OmzrLnXHfuVp0h4Y1CcYjbaj6uqUfm4e3k8xUKqwez/\n\
|
||
8cs7D+xhlpncf5z0ZaMJFS8bgRRUOReB2+qAcJowxJ/J+bwxHAC9y2sCgYEA1/TP\n\
|
||
gCXVt2Hh+mpwLkg1nYJItDJzGJwH8uN3pD53i03qRsfGdHaf+JHFXQF6XpupyvlZ\n\
|
||
0jR7i7/+OY1oqRTfUcApfyUKlOv8bOz6O+DNjh9p2eDx/Oztt4vQgjRqbRVqTFVu\n\
|
||
zwni5ApvIhpz0f22GBBWOt51DpmnTsTwSJplZ/0CgYADW/K9hBiiY2EPrtD997mu\n\
|
||
52dvWtASv0rq+ZxaFmm8Pfewt5qSQXTx4MmsT6snP4ENbR31ucsCqOwTw+jWw72K\n\
|
||
Oxlg16e0PWq/f/S3eq4zGLXdT1Wrp6zOILJLQE8CllRXeUhzeNYRczwAiNW6jTcC\n\
|
||
ZLkv1xRCRq25SAGuj9wSzQKBgQCIjWQnw8S/kEUz8tm8aix8zETsrHnatc7Q5sRg\n\
|
||
Np+glkPtPaVfPyMoKgSCKs0VxZg3oDQLluQIGf7GpYPoZipPpxKWMvXd9NpIhhA0\n\
|
||
jJFtrK9h9bsOE0K9LMtLiZlCIKh2XA8VG0s8ptxe1BsoTSU3Uh00XDXoZYBFboIB\n\
|
||
Zp94gQKBgQCR5mcD8JIWOts0ZxrTwho2kg898WRINusaIIhrCFPoWymvLpoeRzkG\n\
|
||
KvOt9T3KXVzT6lqmBRfZO50Dd9N7+oxYEA7OJb1JJ4WUmOn5llJOgsVmaT4iVdj6\n\
|
||
FqFAwmMOl6/hbaIXBUZ4q/QbzZLxmezOu0XwUzQ4ptvdgaab2qSkmQ==\n\
|
||
-----END RSA PRIVATE KEY-----";
|
||
|
||
static const char* BOT_private = "-----BEGIN RSA PRIVATE KEY-----\n\
|
||
MIIEpAIBAAKCAQEAx6wmsx+MqvvLqCpnNFT76ebpP9CHnwiv4uvGXVGEv9LJXPOw\n\
|
||
OUV8Iwrvgst8ZQWJGO2lTIwLhTQ6piyq1H0NOWtsFKtQHZm1MrjDs51w8OOwgWUb\n\
|
||
TKslQ9cSgHZ+MsNB/Tk8La2C1mDmWt0Ae0CEMY8/q/xdpWsxd+2XodwRVFKfwF3f\n\
|
||
VnjzA5gVE18c/81dJ1UF5QuPkgp8o3+sXpRLElajyFjfbTg/74phOOiyPcEptbl8\n\
|
||
/Mz6QilVCkHEW2f3CcIx7ttAoQIDMqiOVgECOMdWSW1roKCSNsQHOUYFZ7EkpZiB\n\
|
||
Py9qGMI2woXsc8UPgXppl/Buz21zd87TQmlqlQIDAQABAoIBAFKnf6mcgMVyz/4/\n\
|
||
91LhbxqHHLzu3IVHuk9sHEQa76HcZsCUm7lJezaiWz1AcLD81qC8FzYVrtsoILMT\n\
|
||
QHAPh/7h6e6wb8yhCTIC6/gZT1xYVINr0B4vppBrolwNMPZgf5uMKs4ZylRl7lVk\n\
|
||
sMNUlKRTUR8nq7hDJEopzyAQkhfeFGyvid8i9lsHjHZhcU+b0jdDUoEs9/pLQ94+\n\
|
||
Nt7Kh/Xn0cyiUmycuVZyhjFqCiK/egohDbiKDIV9rfMupQAQCprJfo5T5Iy/zncW\n\
|
||
XS8/Oz/9bE8yRNPOhjj/32KSrTNPgdmDE7aT8Ntloh5FXSISSzYHqpn+DWRVD3iY\n\
|
||
+EjIMKECgYEA8aO5PN5/omL3CroKa9LV8Oa0fRbhKKJMaTzgIAIoHLBWgoVkPUER\n\
|
||
ALStMvCeYy3By/gSHakrf4vTjDn+cnC1Wfw8riYf0N0oQD6lZHSbBslToAiIsMD7\n\
|
||
lfWhSW8MEfnKKjWru0/sGmaBcBuBtIb9WSJ/MTmFr8U3zMFsBsMPyp0CgYEA04nx\n\
|
||
+sI2KmaTxxPZ/liUjMnRWd+ZgTlMAdDp/a7CwzDPhp0U27TxITYNf5/sg+rxx570\n\
|
||
0XuMhUHNmoeAs7fmtJ37fqvX117guTwUaSe5UdoO3MHwr4fE+Xc70daMuqaPpwAa\n\
|
||
srAIbJGITIvdCOPK6whRkRL8Vjd9ljO04LGVwlkCgYEAwYbm7KEmh9/LC4REpGaP\n\
|
||
ggjDtQuF+Q1DNWXT+s6/YXq5Tn+W8JgUDgSmUo3zzGrxM3LSz36Vn+lU3JH1/6HV\n\
|
||
HOSvlKpkANufSRTjUbkyEBVeLGWpVCa7WDcJnc6aVCtChtvFVpeD+QDv2eGt1+/l\n\
|
||
KGZAiCQRtdy1+/9NjXzcQOECgYEAuK8JnVTrt08BG+CABOhPIS+d4CowObrNWhSM\n\
|
||
BVgLYCCAPlVr/XlWwBkR5ee4tV9soUxtD2sfPsQ5ff1pZv5apDv9cxUSh0ylQ/Np\n\
|
||
Gnl8+TI4oZGM0aLmXKo1hrka+mYqqrGTnYfEgwz4A2RkoLtH0LTdiZwaxCcENRuF\n\
|
||
glpollkCgYBuCsAUSV1irzydIktSAT1xEDpgqoeQ1iQR4jD8CR57NI94p1IT7kmZ\n\
|
||
bKkNftJL/DdmvPzuYTQgenR/5GKEw1Ca2O9Caa9YU+KDXI4jgHMBfjxcY4Sc8D2W\n\
|
||
RdC/OfVdFmIXPnB/Twyo7PR2oX1tA+XtL3WLIkkmK1JdB/s2XieMGA==\n\
|
||
-----END RSA PRIVATE KEY-----";
|
||
|
||
static const char* BOT_public = "-----BEGIN PUBLIC KEY-----\n\
|
||
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAx6wmsx+MqvvLqCpnNFT7\n\
|
||
6ebpP9CHnwiv4uvGXVGEv9LJXPOwOUV8Iwrvgst8ZQWJGO2lTIwLhTQ6piyq1H0N\n\
|
||
OWtsFKtQHZm1MrjDs51w8OOwgWUbTKslQ9cSgHZ+MsNB/Tk8La2C1mDmWt0Ae0CE\n\
|
||
MY8/q/xdpWsxd+2XodwRVFKfwF3fVnjzA5gVE18c/81dJ1UF5QuPkgp8o3+sXpRL\n\
|
||
ElajyFjfbTg/74phOOiyPcEptbl8/Mz6QilVCkHEW2f3CcIx7ttAoQIDMqiOVgEC\n\
|
||
OMdWSW1roKCSNsQHOUYFZ7EkpZiBPy9qGMI2woXsc8UPgXppl/Buz21zd87TQmlq\n\
|
||
lQIDAQAB\n\
|
||
-----END PUBLIC KEY-----";
|
||
|
||
// JSON encoded version of BOT public key as in Collaborators
|
||
static const char* BOT_json = "{\"publicKey\":\"\
|
||
-----BEGIN PUBLIC KEY-----\\n\
|
||
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAx6wmsx+MqvvLqCpnNFT7\\n\
|
||
6ebpP9CHnwiv4uvGXVGEv9LJXPOwOUV8Iwrvgst8ZQWJGO2lTIwLhTQ6piyq1H0N\\n\
|
||
OWtsFKtQHZm1MrjDs51w8OOwgWUbTKslQ9cSgHZ+MsNB\\/Tk8La2C1mDmWt0Ae0CE\\n\
|
||
MY8\\/q\\/xdpWsxd+2XodwRVFKfwF3fVnjzA5gVE18c\\/81dJ1UF5QuPkgp8o3+sXpRL\\n\
|
||
ElajyFjfbTg\\/74phOOiyPcEptbl8\\/Mz6QilVCkHEW2f3CcIx7ttAoQIDMqiOVgEC\\n\
|
||
OMdWSW1roKCSNsQHOUYFZ7EkpZiBPy9qGMI2woXsc8UPgXppl\\/Buz21zd87TQmlq\\n\
|
||
lQIDAQAB\\n\
|
||
-----END PUBLIC KEY-----\"}";
|
||
|
||
// JSON encoded version of BOT public key
|
||
static const char* BOT_jsonkey = "\"\
|
||
-----BEGIN PUBLIC KEY-----\\n\
|
||
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAx6wmsx+MqvvLqCpnNFT7\\n\
|
||
6ebpP9CHnwiv4uvGXVGEv9LJXPOwOUV8Iwrvgst8ZQWJGO2lTIwLhTQ6piyq1H0N\\n\
|
||
OWtsFKtQHZm1MrjDs51w8OOwgWUbTKslQ9cSgHZ+MsNB\\/Tk8La2C1mDmWt0Ae0CE\\n\
|
||
MY8\\/q\\/xdpWsxd+2XodwRVFKfwF3fVnjzA5gVE18c\\/81dJ1UF5QuPkgp8o3+sXpRL\\n\
|
||
ElajyFjfbTg\\/74phOOiyPcEptbl8\\/Mz6QilVCkHEW2f3CcIx7ttAoQIDMqiOVgEC\\n\
|
||
OMdWSW1roKCSNsQHOUYFZ7EkpZiBPy9qGMI2woXsc8UPgXppl\\/Buz21zd87TQmlq\\n\
|
||
lQIDAQAB\\n\
|
||
-----END PUBLIC KEY-----\"";
|
||
|
||
static const char* BOT_tgi_encrypted = "ZZKY8mDLpOfL1KEr+I+Jc0327p1AoSbB3189wQpzBvzLWNsdIySaRRKJQnzov\
|
||
7iP784VkF8awVcARhZ5Nklwv0m3pps1eUFEG8ivMPVSKyNmTz/CmcAAWZ7TOm/8lApHJsWbHSX76j8zYygpqrL6q4oV+vVxqFTbl9\
|
||
gL+YD4cMb6BE3T0jAi19fMyEWVLX62l/VZsdZscGIPonH/hsvz8YkJry3qAOiixmAo6Pe9UsmhJxv6qFy7u+0bB8NF+iCf0iBwDp5\
|
||
PO32n1nhq80E80p2f8H5ag8mM1OJ5iDzwUxKpkRr7Gpct2lqmidQ2o1bWu0Esgd1hof/gKXEyPxyntw==";
|
||
|
||
//static const unsigned char BOTtgi[32] = {0, 0, 0, 0, 0, 0, 0, 112, 0, 0, 0, 0, 0, 0, 0, 112, 30, 0, 0, 0, 0, 0, 0, 0, -64, 76, 100, -61, -46, 127, 0, 0};
|
||
static const unsigned char BOTtgi[32] = {0, 0, 0, 0, 0, 0, 0, 112, 0, 0, 0, 0, 0, 0, 0, 112, 30, 0, 0, 0, 0, 0, 0, 0, 192, 76, 100, 195, 210, 127, 0, 0};
|
||
|
||
using namespace std;
|
||
using namespace sequencelogic;
|
||
|
||
|
||
int testfailed (const char* inf, const char* msg)
|
||
{
|
||
printf ("FAILED: %s: %s\n", inf, msg);
|
||
return 1;
|
||
}
|
||
|
||
int testfailed (const std::string& inf, const std::string& msg)
|
||
{
|
||
cout << "FAILED: " << inf << ": " << msg << endl;
|
||
//printf ("FAILED: %s : %s\n", inf.c_str(), msg.c_str());
|
||
return 1;
|
||
}
|
||
|
||
char* fileload (const char* filename)
|
||
{
|
||
ifstream file (filename, ios::in | ios::binary | ios::ate);
|
||
char* buff = nullptr;
|
||
if (file.is_open()) {
|
||
size_t bytes = (size_t)file.tellg();
|
||
file.seekg (0, ios::beg);
|
||
buff = new char[bytes + 1];
|
||
file.read (buff, bytes);
|
||
file.close();
|
||
buff[bytes] = '\0';
|
||
}
|
||
return buff;
|
||
}
|
||
|
||
void filewrite (const char* filename, const char* bytes)
|
||
{
|
||
ofstream file (filename, ios::out | ios::binary | ios::trunc);
|
||
if (file.is_open()) {
|
||
file.write (bytes, strlen(bytes) + 1);
|
||
file.close();
|
||
}
|
||
}
|
||
|
||
void filedump (const char* filename)
|
||
{
|
||
ifstream file (filename, ios::in | ios::binary | ios::ate);
|
||
if (file.is_open())
|
||
{
|
||
size_t bytes = (size_t)file.tellg();
|
||
file.seekg (0, ios::beg);
|
||
char* big = new char[bytes + 1];
|
||
if (big) {
|
||
file.read (big, bytes);
|
||
file.close();
|
||
big[bytes] = '\0';
|
||
printf ("%s\n", big);
|
||
delete[] big;
|
||
}
|
||
}
|
||
}
|
||
|
||
bool filecompare (const char* f1, const char* f2)
|
||
{
|
||
std::string f1md5 = sequencelogic::DigestFile ("md5", f1);
|
||
std::string f2md5 = sequencelogic::DigestFile ("md5", f2);
|
||
return f1md5 == f2md5;
|
||
}
|
||
|
||
int locktestfailed (const char* inf, const char* msg)
|
||
{
|
||
printf ("FAILED: %s: %s\n", inf, msg);
|
||
filedump ("test/.ctest.ionu.lk");
|
||
return 1;
|
||
}
|
||
|
||
// Parse an urn, if valid get the urn back and compare
|
||
bool CheckURN (const char* urn)
|
||
{
|
||
bool rc = false;
|
||
EyeURN* u = new EyeURN (urn);
|
||
if (u->IsValid()) {
|
||
char* n = u->GetURN();
|
||
if (n && strcmp (n, urn) == 0)
|
||
rc = true;
|
||
else {
|
||
IONUDEBUG ("%s, %s", urn, n);
|
||
}
|
||
delete[] n;
|
||
}
|
||
delete u;
|
||
return rc;
|
||
}
|
||
|
||
|
||
int TestLogging()
|
||
{
|
||
printf ("\nLogging tests\n-------------------------------\n");
|
||
IONUDEBUG ("%s:%d logging test", __FILE__, __LINE__);
|
||
int rc = 0;
|
||
Keyring ring ("testring", "Test Key Ring");
|
||
ring.GenerateECKey ("MyAudit", "deterministic", challenges);
|
||
char* pk = ring.GetPubKey ("MyAudit");
|
||
Key* pubkey = new Key ("AuditPublic", "My auditing public key", (int)strlen(pk), (const unsigned char*)pk, Key::EC_PUBLIC);
|
||
ring.AddKey (pubkey);
|
||
Key RSA ("Auditor", "RSA auditing key", (int)strlen(RSA_private), (const unsigned char*)RSA_private, Key::RSA);
|
||
delete[] pk;
|
||
|
||
remove ("test/mylog.log");
|
||
IONUCONFIGFILELOG ("audit", "urn:sl:000000:17C38E5A:C60D:79916D07C42C - Nexus-7", EyeLog::IONU_WARN, "test/mylog.log", EyeLog::IONU_FILE, "%l: %m");
|
||
IONUBEGINAUDIT (*(ring.GetKey ("MyAudit")), "test");
|
||
IONUAUDIT (EyeLog::ACCOUNT_CREATE, "madman, madman@sequencelogic.net, 303-217-8477");
|
||
IONUAUDIT (EyeLog::DEVICE_PROVISION, "Nexus-7 4.4.1");
|
||
IONUAUDIT (EyeLog::ACCOUNT_LOGIN, "Failed: invalid password");
|
||
IONUAUDIT (EyeLog::ACCOUNT_LOGIN, "Succeeded");
|
||
IONUCLOSELOG();
|
||
EyeLog::GetInstance()->ReviewAudit (*(ring.GetKey ("MyAudit")), "test/audit.ioa");
|
||
|
||
// Test the basics
|
||
IONUCONFIGLOG ("test", "urn:sl:000000:17C38E5A:C60D:79916D07C42C - Nexus-7", EyeLog::IONU_WARN, EyeLog::IONU_CONSOLE, "%l: %m");
|
||
IONULOG (EyeLog::IONU_INFO, "%s", "Simple log message");
|
||
IONUFATAL ("Fatal message");
|
||
IONUERROR ("Error message");
|
||
IONUWARN ("Warning message");
|
||
IONUINFO ("not ***Info message");
|
||
IONUDEBUG ("not ***Debug message");
|
||
IONUTRACE ("not ***Trace message");
|
||
EyeLog::GetInstance()->SetLogLevel (EyeLog::IONU_TRACE);
|
||
IONUINFO ("Info message");
|
||
IONUDEBUG ("Debug message");
|
||
IONUTRACE ("Trace message");
|
||
IONUCONFIGFILELOG ("ftest", "urn:sl:000000:17C38E5A:C60D:79916D07C42C - Nexus-7", EyeLog::IONU_WARN, "test/mylog.log", EyeLog::IONU_FILE, "%l: %m");
|
||
IONUERROR ("Message only in the file");
|
||
IONUCONFIGFILELOG ("ftest", "urn:sl:000000:17C38E5A:C60D:79916D07C42C - Nexus-7", EyeLog::IONU_WARN, "test/mylog.log", EyeLog::IONU_CONSOLE, "%l: %m");
|
||
IONUERROR ("Message in the file and to the console");
|
||
IONUCLOSELOG("test/mylog.log"); // Close the log file, but keep messages to the console
|
||
printf ("File contents -------\n");
|
||
fstream lfile ("test/mylog.log");
|
||
if (lfile.is_open()) {
|
||
std::string line;
|
||
while (std::getline(lfile, line))
|
||
cout << line << endl;
|
||
}
|
||
printf ("-------\n");
|
||
lfile.close();
|
||
|
||
#ifndef WIN32
|
||
// VS 2012 does not support variadic templates so don't crash with these tests
|
||
IONUWARN ("Not enough args %s %d %f", "missing two");
|
||
IONUWARN ("Too many args %d", "have 3, need one", 7, 33.33);
|
||
IONUWARN ("Wrong arg types, but that's ok (%d %f %s)", "int float string", 13, 99.99);
|
||
IONUWARN ("%% at the end of just a string %");
|
||
IONUWARN ("%% at the end with an argument %", 7);
|
||
IONUWARN (cgurl);
|
||
IONUWARN ("null pointer %s", NULL);
|
||
|
||
// Test various custom formats
|
||
IONUCONFIGLOG ("IM", "dev", EyeLog::IONU_WARN, EyeLog::IONU_CONSOLE, "[%L]|%c|%t|%m");
|
||
IONUWARN ("Format [%%L]|%%c|%%t|%%m");
|
||
IONUCONFIGLOG ("IM", "dev", EyeLog::IONU_WARN, EyeLog::IONU_CONSOLE, "%l:%c:%m");
|
||
IONUWARN ("Format %%l:%%c:%%m");
|
||
IONUCONFIGLOG ("IM", "dev", EyeLog::IONU_WARN, EyeLog::IONU_CONSOLE, "%l - %m");
|
||
IONUWARN ("Format %%l - %%m");
|
||
IONUCONFIGLOG ("smo", "dev", EyeLog::IONU_WARN, EyeLog::IONU_CONSOLE, "%l - %m <%c>");
|
||
IONUWARN ("Format %%l - %%m <%%c>");
|
||
IONUCONFIGLOG ("smo", "dev", EyeLog::IONU_INFO, EyeLog::IONU_CONSOLE, "%ems %l - %m");
|
||
IONUWARN ("Format %%eMs %%l- %%m");
|
||
#endif
|
||
|
||
// Test file based logging
|
||
IONUCONFIGFILELOG ("im", "urn:sl:000000:17C38E5A:C60D:79916D07C42C - TestPad", EyeLog::IONU_WARN, "test/mylog.log", EyeLog::IONU_FILE, "%l: %m");
|
||
EyeLog::GetInstance()->SetMaxLogFile (300);
|
||
IONUWARN ("This is a custom warning message with %d options", 273);
|
||
IONUWARN ("This is a custom warning message with %d options", 274);
|
||
IONUWARN ("This is a custom warning message with %d options", 275);
|
||
IONUWARN ("This is a custom warning message with %d options", 276);
|
||
IONUWARN ("This is a custom warning message with %d options", 277);
|
||
IONUWARN ("This is a custom warning message with %d options", 278);
|
||
IONUWARN ("This is a custom warning message with %d options", 279);
|
||
IONUWARN ("This is a custom warning message with %d options", 280);
|
||
IONUWARN ("This is a custom warning message with %d options", 281);
|
||
IONUWARN ("This is a custom warning message with %d options", 282);
|
||
IONUWARN ("This is a custom warning message with %d options", 283);
|
||
IONUWARN ("This is a custom warning message with %d options", 284);
|
||
IONUWARN ("This is a custom warning message with %d options", 285);
|
||
IONUCLOSELOG ("test/mylog.log");
|
||
EyeLog::GetInstance()->SetMaxLogFile (IONU_MAX_LOG_FILE_SIZE);
|
||
|
||
EyeLog::GetInstance()->ConfigLogger ("IM", "urn:sl:000000:17C38E5A:C60D:79916D07C42C - TestPad", EyeLog::IONU_AUDIT, EyeLog::IONU_CONSOLE);
|
||
EyeLog::GetInstance()->BeginAudit (RSA, "test");
|
||
|
||
IONUAUDIT (EyeLog::ACCOUNT_CREATE, "madman, madman@sequencelogic.net, 303-217-8477");
|
||
IONUAUDIT (EyeLog::DEVICE_PROVISION, "Nexus-7 4.3.1");
|
||
IONUAUDIT (EyeLog::ACCOUNT_LOGIN, "Failed: invalid password");
|
||
IONUAUDIT (EyeLog::ACCOUNT_LOGIN, "ip:192.168.8.101");
|
||
IONUAUDIT (EyeLog::ACCOUNT_CHANGE, "Added Avatar");
|
||
IONUAUDIT (EyeLog::ACCOUNT_CHANGE, "Added contect: <Nikki>");
|
||
IONUAUDIT (EyeLog::DOCUMENT_SEND, "Message To: <Nikki>");
|
||
IONUAUDIT (EyeLog::DOCUMENT_RECEIVE, "Message From: <Nikki>");
|
||
IONUAUDIT (EyeLog::ACCOUNT_LOGOUT, "time limit expired");
|
||
IONUWARN ("This warning should not appear");
|
||
IONUCONFIGLOG ("IM1", "dev", EyeLog::IONU_WARN, EyeLog::IONU_CONSOLE);
|
||
IONUWARN ("This warning should appear");
|
||
IONUCLOSELOG();
|
||
printf ("--Reviewing IM.ioa\n");
|
||
if (!EyeLog::GetInstance()->ReviewAudit (RSA, "test/IM.ioa"))
|
||
rc += testfailed ("EyeLog::ReviewAudit (RSA, test/IM.ioa)", "");
|
||
printf ("--Reviewing badaudit.ioa\n");
|
||
if (EyeLog::GetInstance()->ReviewAudit (RSA, "test/badaudit.ioa"))
|
||
rc += testfailed ("EyeLog::ReviewAudit (RSA, test/badaudit.ioa", "");
|
||
printf ("--Reviewing badauditk.ioa\n");
|
||
if (EyeLog::GetInstance()->ReviewAudit (RSA, "test/badauditk.ioa"))
|
||
rc += testfailed ("EyeLog::ReviewAudit (RSA, test/badauditk.ioa", "");
|
||
|
||
//printf ("--Audit consolidation tests\n");
|
||
|
||
//if (!EyeLog::GetInstance()->ReviewAudit (RSA, "test/first.ioa"))
|
||
// rc += testfailed ("EyeLog::ReviewAudit (RSA, test/first.ioa", "pre-consolidation");
|
||
//EyeLog::GetInstance()->ConsolidateAudit (RSA, "test/first.ioa", "test/second.ioa");
|
||
//if (!EyeLog::GetInstance()->ReviewAudit (RSA, "test/first.ioa"))
|
||
// rc += testfailed ("EyeLog::ReviewAudit (RSA, test/first.ioa", "consolidated");
|
||
|
||
if (rc)
|
||
printf ("%d log tests failed\n", rc);
|
||
else
|
||
printf ("logging and audit tests passed\n");
|
||
return rc;
|
||
}
|
||
|
||
int TestFileThreadLocking()
|
||
{
|
||
int rc = 0;
|
||
#ifdef LOCK_STRATEGY_MEMORY
|
||
printf ("\nMemory file locking tests\n-------------------------------\n");
|
||
|
||
if (sequencelogic::ThreadLockFile ("lockfile.ionu", "you", IONU_FILE_LOCK_WRITE) != IONU_FILE_LOCK_OK)
|
||
rc += testfailed ("failed to get initial write lock", "you");
|
||
if (sequencelogic::ThreadLockFile ("lockfile.ionu", "me", IONU_FILE_LOCK_READ) == IONU_FILE_LOCK_OK)
|
||
rc += testfailed ("got read lock when should not have", "me");
|
||
if (sequencelogic::ThreadLockFile ("lockfile.ionu", "you", IONU_FILE_LOCK_CLEAR) != IONU_FILE_LOCK_OK)
|
||
rc += testfailed ("failed to release initial write lock", "you");
|
||
if (EyeFileThreadLocker::GetInstance()->GetNumLocks() > 0)
|
||
rc += testfailed ("should be 0 locks", "you");
|
||
|
||
EyeFileThreadLock* locka = new EyeFileThreadLock (IONU_FILE_LOCK_READ, "lockfile.ionu", "me");
|
||
EyeFileThreadLock* lockb = new EyeFileThreadLock (IONU_FILE_LOCK_READ, "lockfile.ionu", "you");
|
||
if (!locka->acquired() || !lockb->acquired())
|
||
rc += testfailed ("2 read locks", "a and b");
|
||
else
|
||
cout << "2 read locks acquired" << endl;
|
||
if (locka->convertToWrite())
|
||
rc += testfailed ("convert read lock should have failed", "a");
|
||
else
|
||
cout << sequencelogic::GetLastEyeLockMessage() << endl;
|
||
delete lockb;
|
||
if (!locka->convertToWrite())
|
||
rc += testfailed ("convert read lock", "a");
|
||
lockb = new EyeFileThreadLock (IONU_FILE_LOCK_READ, "lockfile.ionu", "you");
|
||
if (lockb->acquired())
|
||
rc += testfailed ("read lock should have failed", "b");
|
||
else
|
||
cout << sequencelogic::GetLastEyeLockMessage() << endl;
|
||
delete locka;
|
||
delete lockb;
|
||
EyeFileThreadWriteLock* wlock = new EyeFileThreadWriteLock ("lockfile.ionu", "wlok");
|
||
if (!wlock->acquired())
|
||
rc += testfailed ("failed to get write lock", "wlock");
|
||
EyeFileThreadReadLock* rlock = new EyeFileThreadReadLock ("lockfile.ionu", "rlok");
|
||
if (rlock->acquired())
|
||
rc += testfailed ("read lock should have failed", "rlock");
|
||
else
|
||
cout << sequencelogic::GetLastEyeLockMessage() << endl;
|
||
delete rlock;
|
||
delete wlock;
|
||
|
||
EyeFileThreadReadLock readlock ("lockfile.ionu", "me");
|
||
if (!readlock.acquired())
|
||
rc += testfailed ("read lock", "me");
|
||
if (sequencelogic::ThreadLockFile ("lockfile.ionu", "you", IONU_FILE_LOCK_WRITE) == IONU_FILE_LOCK_OK)
|
||
rc += testfailed ("thread lock write", "you");
|
||
if (!readlock.convertToWrite())
|
||
rc += testfailed ("convert write lock", "me");
|
||
else
|
||
cout << "converted to write" << endl;
|
||
if (!readlock.convertToRead())
|
||
rc += testfailed ("convert read lock", "me");
|
||
else
|
||
cout << "converted to read" << endl;
|
||
if (!readlock.release())
|
||
rc += testfailed ("release read lock", "me");
|
||
if (readlock.release())
|
||
rc += testfailed ("no lock to release", "me");
|
||
if (!readlock.acquire(IONU_FILE_LOCK_READ))
|
||
rc += testfailed ("reacquire read lock", "me");
|
||
else
|
||
cout << "released and re-acquired" << endl;
|
||
|
||
IONU_FILE_LOCK_STATUS st;
|
||
st = sequencelogic::ThreadLockFile ("cantlocklock.lk", "me", IONU_FILE_LOCK_READ); // My read lock
|
||
if (st == IONU_FILE_LOCK_OK)
|
||
rc += locktestfailed ("ThreadLockFile() read lock on", "cantlocklock.lk");
|
||
|
||
st = sequencelogic::ThreadLockFile ("thisfiledoesnotexistyet", "me", IONU_FILE_LOCK_READ); // My read lock
|
||
if (st != IONU_FILE_LOCK_OK)
|
||
rc += locktestfailed ("ThreadLockFile() read lock - me", "thisfiledoesnotexistyet");
|
||
st = sequencelogic::ThreadLockFile ("thisfiledoesnotexistyet", "me", IONU_FILE_LOCK_CLEAR); // Clear my lock
|
||
if (st != IONU_FILE_LOCK_OK)
|
||
rc += locktestfailed ("LockFile() read lock - you", "thisfiledoesnotexistyet");
|
||
else
|
||
printf ("Lock and clear of non-existant file passed\n");
|
||
|
||
if (rc)
|
||
printf ("%d lock tests failed\n", rc);
|
||
else
|
||
printf ("lock tests passed\n");
|
||
#endif
|
||
return rc;
|
||
}
|
||
|
||
int TestProcessLocking()
|
||
{
|
||
int rc = 0;
|
||
#ifdef LOCK_STRATEGY_MASTER
|
||
//printf ("\nProcess file locking tests\n-------------------------------\n");
|
||
//EyeContainer* IOnU = new EyeContainer("test/lockfile.ionu", TGIkey, URN, TopicPerms);
|
||
//IOnU->AddTextMessage (".imchat", "A long and verbose yo there to you from me type chat message to test various stuff with");
|
||
//IOnU->Finalize();
|
||
//delete IOnU;
|
||
|
||
EyeFileProcessLock* locka = new EyeFileProcessLock (IONU_FILE_LOCK_READ, "test/lockfile.ionu", "a");
|
||
if (!locka->acquired())
|
||
rc += testfailed ("read lock", "a");
|
||
else
|
||
cout << "read lock a acquired" << endl;
|
||
EyeFileProcessLock* lockb = new EyeFileProcessLock (IONU_FILE_LOCK_READ, "test/lockfile.ionu", "b");
|
||
if (!locka->acquired() || !lockb->acquired())
|
||
rc += testfailed ("2 read locks", "a and b");
|
||
else
|
||
cout << "2 read locks acquired" << endl;
|
||
//cout << EyeContainer::GetMetaDataClassic ("test/lockfile.ionu") << endl;
|
||
if (locka->convertToWrite())
|
||
rc += testfailed ("convert read lock should have failed", "a");
|
||
else
|
||
cout << sequencelogic::GetLastEyeLockMessage() << endl;
|
||
delete lockb;
|
||
if (!locka->convertToWrite()) {
|
||
rc += testfailed ("convert read lock", "a");
|
||
cout << sequencelogic::GetLastEyeLockMessage() << endl;
|
||
}
|
||
lockb = new EyeFileProcessLock (IONU_FILE_LOCK_READ, "test/lockfile.ionu", "b");
|
||
if (lockb->acquired())
|
||
rc += testfailed ("read lock should have failed", "b");
|
||
else
|
||
cout << sequencelogic::GetLastEyeLockMessage() << endl;
|
||
delete locka;
|
||
delete lockb;
|
||
EyeFileProcessWriteLock* wlock = new EyeFileProcessWriteLock ("test/lockfile.ionu", "w");
|
||
if (!wlock->acquired())
|
||
rc += testfailed ("failed to get write lock", "wlock");
|
||
else
|
||
cout << "write lock a acquired" << endl;
|
||
|
||
//IOnU = new EyeContainer("test/lockfile.ionu", TGIkey);
|
||
//cout << IOnU->GetTextMessage (".imchat") << endl;
|
||
//IOnU->AddTextMessage (".imchat", "Short chat");
|
||
//IOnU->Finalize();
|
||
//delete IOnU;
|
||
//IOnU = new EyeContainer("test/lockfile.ionu", TGIkey);
|
||
//cout << IOnU->GetTextMessage (".imchat") << endl;
|
||
//delete IOnU;
|
||
|
||
EyeFileProcessReadLock* rlock = new EyeFileProcessReadLock ("test/lockfile.ionu", "r");
|
||
if (rlock->acquired())
|
||
rc += testfailed ("read lock should have failed", "rlock");
|
||
else
|
||
cout << sequencelogic::GetLastEyeLockMessage() << endl;
|
||
delete rlock;
|
||
delete wlock;
|
||
cout << "deleted read and write locks" << endl;
|
||
|
||
EyeFileProcessReadLock readlock ("test/lockfile.ionu", "r");
|
||
if (!readlock.acquired())
|
||
rc += testfailed ("read lock", "me");
|
||
if (!readlock.convertToWrite())
|
||
rc += testfailed ("convert write lock", "me");
|
||
else
|
||
cout << "converted to write" << endl;
|
||
if (!readlock.convertToRead())
|
||
rc += testfailed ("convert read lock", "me");
|
||
else
|
||
cout << "converted to read" << endl;
|
||
if (!readlock.release())
|
||
rc += testfailed ("release read lock", "me");
|
||
if (!readlock.acquire(IONU_FILE_LOCK_READ))
|
||
rc += testfailed ("reacquire read lock", "me");
|
||
else
|
||
cout << "released and re-acquired" << endl;
|
||
|
||
IONU_FILE_LOCK_STATUS st;
|
||
st = sequencelogic::ProcessLockFile ("cantlocklock.lk", "me", IONU_FILE_LOCK_READ); // My read lock
|
||
if (st == IONU_FILE_LOCK_OK)
|
||
rc += locktestfailed ("ProcessLockFile() read lock on", "cantlocklock.lk");
|
||
|
||
st = sequencelogic::ProcessLockFile ("thisfiledoesnotexistyet", "me", IONU_FILE_LOCK_READ); // My read lock
|
||
if (st != IONU_FILE_LOCK_OK)
|
||
rc += locktestfailed ("ProcessLockFile() read lock - me", "thisfiledoesnotexistyet");
|
||
st = sequencelogic::ProcessLockFile ("thisfiledoesnotexistyet", "me", IONU_FILE_LOCK_CLEAR); // Clear my lock
|
||
if (st != IONU_FILE_LOCK_OK)
|
||
rc += locktestfailed ("LockFile() read lock - you", "thisfiledoesnotexistyet");
|
||
else
|
||
printf ("Lock and clear of non-existant file passed\n");
|
||
|
||
if (rc)
|
||
printf ("%d lock tests failed\n", rc);
|
||
else
|
||
printf ("lock tests passed\n");
|
||
|
||
#endif
|
||
return rc;
|
||
}
|
||
|
||
int TestRAIIRead()
|
||
{
|
||
int rc = 0;
|
||
EyeFileReadLock readlock (cionu, "raii");
|
||
if (sequencelogic::LockFile (cionu, "me", IONU_FILE_LOCK_READ) != IONU_FILE_LOCK_OK)
|
||
rc += testfailed ("EyeFileReadLock(RAII) read lock", "me");
|
||
if (sequencelogic::LockFile (cionu, "me", IONU_FILE_LOCK_CLEAR) != IONU_FILE_LOCK_OK)
|
||
rc += testfailed ("EyeFileReadLock(RAII) clear lock", "me");
|
||
if (sequencelogic::LockFile (cionu, "me", IONU_FILE_LOCK_WRITE) == IONU_FILE_LOCK_OK)
|
||
rc += testfailed ("EyeFileReadLock(RAII) read lock", "me");
|
||
return rc;
|
||
}
|
||
int TestRAIIWrite()
|
||
{
|
||
int rc = 0;
|
||
EyeFileWriteLock readlock (cionu, "raii");
|
||
if (sequencelogic::LockFile (cionu, "me", IONU_FILE_LOCK_READ) == IONU_FILE_LOCK_OK)
|
||
rc += testfailed ("EyeFileWriteLock(RAII) read lock", "me");
|
||
if (sequencelogic::LockFile (cionu, "me", IONU_FILE_LOCK_WRITE) == IONU_FILE_LOCK_OK)
|
||
rc += testfailed ("EyeFileWriteLock(RAII) write lock", "me");
|
||
return rc;
|
||
}
|
||
|
||
int TestFileLocking()
|
||
{
|
||
printf ("\nFile locking tests\n-------------------------------\n");
|
||
int rc = 0;
|
||
//ionu_eyefile_create_with_message ("test/remove_test.ionu", TGIkey, ".imchatty", "Yo!", 3, URN, PERMS);
|
||
sequencelogic::EyeFileLock* ef = new EyeFileLock(IONU_FILE_LOCK_READ, "test/remove_test.ionu", "remove");
|
||
sequencelogic::RemoveFile ("test/remove_test.ionu");
|
||
delete ef;
|
||
if (sequencelogic::CanReadFile ("test/.remove_test.ionu.lk"))
|
||
rc += locktestfailed ("RemoveEntry() lock not deleted", "test/.remove_test.ionu.lk");
|
||
|
||
IONU_FILE_LOCK_STATUS st;
|
||
st = sequencelogic::LockFile ("cantlocklock.lk", "me", IONU_FILE_LOCK_READ); // My read lock
|
||
if (st == IONU_FILE_LOCK_OK)
|
||
rc += locktestfailed ("LockFile() read lock on", "cantlocklock.lk");
|
||
|
||
st = sequencelogic::LockFile ("thisfiledoesnotexistyet", "me", IONU_FILE_LOCK_READ); // My read lock
|
||
if (st != IONU_FILE_LOCK_OK)
|
||
rc += locktestfailed ("LockFile() read lock - me", "thisfiledoesnotexistyet");
|
||
st = sequencelogic::LockFile ("thisfiledoesnotexistyet", "me", IONU_FILE_LOCK_CLEAR); // Clear my lock
|
||
if (st != IONU_FILE_LOCK_OK)
|
||
rc += locktestfailed ("LockFile() read lock - you", "thisfiledoesnotexistyet");
|
||
else
|
||
printf ("Lock and clear of non-existant file passed\n");
|
||
if (sequencelogic::CanReadFile ("test/.thisfiledoesnotexistyet.lk"))
|
||
rc += locktestfailed ("LockFile() lockfile not deleted after clear", "test/.thisfiledoesnotexistyet.lk");
|
||
|
||
st = sequencelogic::LockFile (cionu, "me", IONU_FILE_LOCK_READ); // My read lock
|
||
if (st != IONU_FILE_LOCK_OK)
|
||
rc += locktestfailed ("LockFile() read lock - me", cionu);
|
||
st = sequencelogic::LockFile (cionu, "you", IONU_FILE_LOCK_WRITE); // Fails to get your write lock
|
||
cout << sequencelogic::GetLastEyeLockMessage() << endl;
|
||
if (st == IONU_FILE_LOCK_OK)
|
||
rc += locktestfailed ("LockFile() write lock - you", cionu);
|
||
else
|
||
printf ("Basic write lock test me and you passed\n");
|
||
|
||
st = sequencelogic::LockFile (cionu, "me", IONU_FILE_LOCK_CLEAR); // Clear my lock
|
||
if (st != IONU_FILE_LOCK_OK)
|
||
rc += locktestfailed ("LockFile() read lock - you", cionu);
|
||
else
|
||
printf ("Clear lock passed\n");
|
||
if (sequencelogic::CanReadFile ("test/.ctest.ionu.lk"))
|
||
rc += locktestfailed ("LockFile() lockfile not deleted after clear", "test/.ctest.ionu.lk");
|
||
else
|
||
printf ("Lock file deleted\n");
|
||
|
||
st = sequencelogic::LockFile (cionu, "me", IONU_FILE_LOCK_CLEAR); // Clear lock on non-existant lock file
|
||
if (st != IONU_FILE_LOCK_OK)
|
||
rc += locktestfailed ("LockFile() cleared read lock", cionu);
|
||
else
|
||
printf ("Double clear lock passed\n");
|
||
if (sequencelogic::CanReadFile ("test/.ctest.ionu.lk"))
|
||
rc += locktestfailed ("LockFile() lockfile not deleted after clear", "test/.ctest.ionu.lk");
|
||
|
||
// Cleared lock, should get it now
|
||
st = sequencelogic::LockFile (cionu, "you", IONU_FILE_LOCK_READ); // Your read lock
|
||
if (st != IONU_FILE_LOCK_OK)
|
||
rc += locktestfailed ("LockFile() read lock - you", cionu);
|
||
else
|
||
printf ("Basic unlock test passed\n");
|
||
|
||
// Multiple read locks
|
||
st = sequencelogic::LockFile (cionu, "me", IONU_FILE_LOCK_READ); // Now we both have read locks
|
||
if (st != IONU_FILE_LOCK_OK)
|
||
rc += locktestfailed ("LockFile() 2nd read lock - me", cionu);
|
||
else
|
||
printf ("Multiple read lock test passed\n");
|
||
|
||
st = sequencelogic::LockFile (cionu, "them", IONU_FILE_LOCK_WRITE); // Their write lock fails
|
||
if (st == IONU_FILE_LOCK_OK)
|
||
rc += locktestfailed ("LockFile() 3rd write lock - you", cionu);
|
||
else
|
||
printf ("Multiple read lock test passed\n");
|
||
|
||
st = sequencelogic::LockFile (cionu, "me", IONU_FILE_LOCK_CLEAR); // Clear my read
|
||
if (st != IONU_FILE_LOCK_OK)
|
||
rc += locktestfailed ("LockFile() read lock - you", cionu);
|
||
st = sequencelogic::LockFile (cionu, "you", IONU_FILE_LOCK_WRITE); // Add your lock to a write
|
||
if (st != IONU_FILE_LOCK_OK)
|
||
rc += locktestfailed ("LockFile() changed to write lock - you", cionu);
|
||
|
||
st = sequencelogic::LockFile (cionu, "me", IONU_FILE_LOCK_READ); // My read lock fails
|
||
if (st == IONU_FILE_LOCK_OK)
|
||
rc += locktestfailed ("LockFile() read lock after you got write - me", cionu);
|
||
else
|
||
printf ("LockFile() read lock after you got write test passed\n");
|
||
st = sequencelogic::LockFile (cionu, "me", IONU_FILE_LOCK_WRITE); // My write lock fails
|
||
cout << sequencelogic::GetLastEyeLockMessage() << endl;
|
||
if (st == IONU_FILE_LOCK_OK)
|
||
rc += locktestfailed ("LockFile() write lock after you got write - me", cionu);
|
||
else
|
||
printf ("LockFile() write lock after you got write test passed\n");
|
||
|
||
st = sequencelogic::LockFile (cionu, "you", IONU_FILE_LOCK_CLEAR); // Clear your write lock
|
||
if (st != IONU_FILE_LOCK_OK)
|
||
rc += locktestfailed ("LockFile() clear write lock - you", cionu);
|
||
st = sequencelogic::LockFile (cionu, "me", IONU_FILE_LOCK_READ); // My read lock succeeds
|
||
if (st == IONU_FILE_LOCK_OK)
|
||
printf ("Removed your write test passed\n");
|
||
else
|
||
rc += locktestfailed ("LockFile() read lock after you got write - me", cionu);
|
||
st = sequencelogic::LockFile (cionu, "you", IONU_FILE_LOCK_CLEAR); // Clear your read lock
|
||
if (st != IONU_FILE_LOCK_OK)
|
||
rc += locktestfailed ("LockFile() clear read lock - you", cionu);
|
||
st = sequencelogic::LockFile (cionu, "me", IONU_FILE_LOCK_CLEAR); // Clear my read lock
|
||
if (st != IONU_FILE_LOCK_OK)
|
||
rc += locktestfailed ("LockFile() clear read lock - me", cionu);
|
||
|
||
// Try to lock a lockfile
|
||
st = sequencelogic::LockFile ("test/.ctest.ionu.lk", "pad", IONU_FILE_LOCK_READ);
|
||
if (st != IONU_FILE_LOCK_ERROR)
|
||
rc += locktestfailed ("LockFile() lock lockfile - pad", "test/.ctest.ionu.lk");
|
||
|
||
EyeFileReadLock readlock (cionu, "me");
|
||
if (!readlock.acquired())
|
||
rc += testfailed ("read lock", "me");
|
||
if (sequencelogic::LockFile (cionu, "you", IONU_FILE_LOCK_WRITE) == IONU_FILE_LOCK_OK)
|
||
rc += testfailed ("thread lock write", "you");
|
||
if (!readlock.convertToWrite())
|
||
rc += testfailed ("convert write lock", "me");
|
||
if (!readlock.convertToRead())
|
||
rc += testfailed ("convert read lock", "me");
|
||
if (!readlock.release())
|
||
rc += testfailed ("release read lock", "me");
|
||
if (!readlock.release())
|
||
rc += testfailed ("no lock to release", "me");
|
||
if (!readlock.acquire(IONU_FILE_LOCK_READ))
|
||
rc += testfailed ("reacquire read lock", "me");
|
||
if (!readlock.release())
|
||
rc += testfailed ("release after reacquire", "me");
|
||
if (sequencelogic::CanReadFile ("test/.ctest.ionu.lk"))
|
||
rc += locktestfailed ("EyeFileReadLock() lockfile not deleted after clear", "test/.ctest.ionu.lk");
|
||
|
||
rc += TestRAIIRead();
|
||
if (sequencelogic::CanReadFile ("test/.ctest.ionu.lk"))
|
||
rc += locktestfailed ("EyeFileReadLock() lockfile not deleted after RAII", "test/.ctest.ionu.lk");
|
||
else
|
||
printf ("RAII read test passed\n");
|
||
rc += TestRAIIWrite();
|
||
if (sequencelogic::CanReadFile ("test/.ctest.ionu.lk"))
|
||
rc += locktestfailed ("EyeFileWriteLock() lockfile not deleted after RAII", "test/.ctest.ionu.lk");
|
||
else
|
||
printf ("RAII write test passed\n");
|
||
|
||
// Test a remote locked file
|
||
std::string remote = "[{\"pid\":\"RSUS-8:7963\",\"id\":\"me\",\"type\":\"W\",\"time\":\"";
|
||
EyeTime now;
|
||
remote += now.GetISO8601Time();
|
||
remote += "\"}]";
|
||
filewrite ("test/.ctest.ionu.lk", remote.c_str());
|
||
filedump ("test/.ctest.ionu.lk");
|
||
st = sequencelogic::LockFile (cionu, "me", IONU_FILE_LOCK_WRITE);
|
||
if (st == IONU_FILE_LOCK_OK)
|
||
rc += locktestfailed ("LockFile() remote lock", cionu);
|
||
else
|
||
printf ("Lock check for remote system locked file passed\n");
|
||
sequencelogic::RemoveFile ("test/.ctest.ionu.lk");
|
||
|
||
// Add a stale lock for the next run
|
||
sequencelogic::LockFile (cionu, "me", IONU_FILE_LOCK_READ);
|
||
filedump ("test/.ctest.ionu.lk");
|
||
if (rc)
|
||
printf ("%d lock tests failed\n", rc);
|
||
else
|
||
printf ("lock tests passed\n");
|
||
return rc;
|
||
}
|
||
|
||
int IONUCompressTests()
|
||
{
|
||
int rc = 0;
|
||
unsigned char compressed[2048];
|
||
unsigned char uncompressed[4098];
|
||
const char* str = "<!DOCTYPE html><html><head><title>Hello HTML</title></head><body><p>Hello World!</p></body></html>";
|
||
|
||
size_t len = strlen (str) + 1;
|
||
size_t dest_len = 2048;
|
||
sequencelogic::Compress (compressed, &dest_len, (unsigned char*)str, len);
|
||
printf ("%d bytes in, %d bytes compressed\n", (int)len, (int)dest_len);
|
||
sequencelogic::Uncompress (uncompressed, &len, compressed, dest_len);
|
||
printf ("%d bytes out\n", (int)len);
|
||
if (memcmp (str, uncompressed, len) != 0)
|
||
rc += testfailed ("HTML compress", (char*)uncompressed);
|
||
len = strlen (vanishMeta) + 1;
|
||
dest_len = 2048;
|
||
sequencelogic::Compress (compressed, &dest_len, (unsigned char*)vanishMeta, len);
|
||
printf ("%d bytes in, %d bytes compressed\n", (int)len, (int)dest_len);
|
||
sequencelogic::Uncompress (uncompressed, &len, compressed, dest_len);
|
||
printf ("%d bytes out\n", (int)len);
|
||
if (memcmp (vanishMeta, uncompressed, len) != 0)
|
||
rc += testfailed ("vanishMeta compress", (char*)uncompressed);
|
||
len = strlen (uploadedMeta) + 1;
|
||
dest_len = 2048;
|
||
sequencelogic::Compress (compressed, &dest_len, (unsigned char*)uploadedMeta, len);
|
||
printf ("%d bytes in, %d bytes compressed\n", (int)len, (int)dest_len);
|
||
sequencelogic::Uncompress (uncompressed, &len, compressed, dest_len);
|
||
printf ("%d bytes out\n", (int)len);
|
||
if (memcmp (uploadedMeta, uncompressed, len) != 0)
|
||
rc += testfailed ("uploadedMeta compress", (char*)uncompressed);
|
||
|
||
ifstream file ("test/system info dump.xml", ios::in | ios::binary | ios::ate);
|
||
if (file.is_open())
|
||
{
|
||
size_t bytes = (size_t)file.tellg();
|
||
file.seekg (0, ios::beg);
|
||
char* big = new char[bytes];
|
||
char* b64 = new char[bytes];
|
||
unsigned char* data = new unsigned char[bytes];
|
||
if (big && data) {
|
||
size_t rbytes = bytes;
|
||
file.read (big, bytes);
|
||
file.close();
|
||
sequencelogic::Compress (data, &bytes, (unsigned char*)big, bytes);
|
||
sequencelogic::Base64Encode (data, bytes, b64);
|
||
bytes = sequencelogic::Base64Decode (b64, data);
|
||
sequencelogic::Uncompress ((unsigned char*)b64, &rbytes, data, bytes);
|
||
if (memcmp (big, b64, rbytes) != 0) {
|
||
rc += testfailed ("Big Xml compress", "test/system info dump.xml");
|
||
big[80] = '\0';
|
||
b64[80] = '\0';
|
||
printf ("%s\n%s\n", big, b64);
|
||
}
|
||
}
|
||
delete[] big;
|
||
delete[] b64;
|
||
delete[] data;
|
||
}
|
||
|
||
return rc;
|
||
}
|
||
|
||
int TestDB()
|
||
{
|
||
printf ("\nDB tests\n-------------------------------\n");
|
||
int rc = 0;
|
||
char* val = NULL;
|
||
EyeEncryptedDB* test = new EyeEncryptedDB ("test/test.db", TestKey);
|
||
std::map<std::string, std::string> entries;
|
||
entries["key1"] = "value1";
|
||
entries["key2"] = "value2";
|
||
entries["key3"] = "value3";
|
||
entries["key4"] = "Longervalueforkey4";
|
||
test->PutAll ("cache", entries, true);
|
||
std::map<std::string, std::string> dbentries = test->GetAll ("cache");
|
||
printf ("got all\n");
|
||
for (std::map<std::string, std::string>::const_iterator itr = dbentries.begin(); itr != dbentries.end(); ++itr) {
|
||
std::cout << itr->first << " " << itr->second << std::endl;
|
||
}
|
||
test->Put ("backup", "key2", "bvalue2");
|
||
// ms = sequencelogic::GetSystemTime();
|
||
// for (int i=0; i<10000; ++i) {
|
||
// val = test->Get ("cache", "key1");
|
||
// delete[] val;
|
||
// }
|
||
// ms = sequencelogic::GetSystemTime() - ms;
|
||
// printf ("Loaded 10,000 values in %ld ms\n", ms);
|
||
val = test->Get ("cache", "key1");
|
||
if (val) {
|
||
printf ("cache.key1.%s\n", val);
|
||
delete[] val;
|
||
}
|
||
else
|
||
rc += testfailed ("Get", "cache.key1");
|
||
|
||
val = test->Get ("cache", "key2");
|
||
if (val) {
|
||
printf ("cache.key2.%s\n", val);
|
||
delete[] val;
|
||
}
|
||
else
|
||
rc += testfailed ("Get", "cache.key2");
|
||
|
||
val = test->Get ("cache", "key3");
|
||
if (val) {
|
||
printf ("cache.key3.%s\n", val);
|
||
delete[] val;
|
||
}
|
||
else
|
||
rc += testfailed ("Get", "cache.key3");
|
||
|
||
val = test->Get ("cache", "key4");
|
||
if (val) {
|
||
printf ("cache.key4.%s\n", val);
|
||
delete[] val;
|
||
}
|
||
else
|
||
rc += testfailed ("Get", "cache.key4");
|
||
|
||
val = test->Get ("backup", "key2");
|
||
if (val) {
|
||
printf ("backup.key2.%s\n", val);
|
||
delete[] val;
|
||
}
|
||
else
|
||
rc += testfailed ("Get", "backup.key2");
|
||
val = test->Get ("cache", "keynot");
|
||
if (val)
|
||
rc += testfailed ("Get", "cache.keynot");
|
||
delete test;
|
||
test = new EyeEncryptedDB ("test/test.db", badkey);
|
||
val = test->Get ("backup", "key2");
|
||
if (val)
|
||
rc += testfailed ("Get() with bad key", "backup.key2");
|
||
else
|
||
printf ("Bad DB key test passed\n");
|
||
delete test;
|
||
test = new EyeEncryptedDB ("test/test.db", TestKey);
|
||
//test->Dump("cache");
|
||
test->Put ("cache", "key2", "NewValue2");
|
||
test->ReKey (badkey);
|
||
//test->Dump("cache");
|
||
delete test;
|
||
test = new EyeEncryptedDB ("test/test.db", badkey);
|
||
val = test->Get ("cache", "key2");
|
||
if (sequencelogic::StrCmp (val, "NewValue2") == 0)
|
||
printf ("cache.key2.%s\n", val);
|
||
else
|
||
rc += testfailed ("Get() after ReKey", "cache.key2");
|
||
if (val) delete[] val;
|
||
test->Remove ("cache", "key2");
|
||
//test->Dump("cache");
|
||
val = test->Get ("cache", "key2");
|
||
if (sequencelogic::StrCmp (val, "value2") == 0)
|
||
rc += testfailed ("Remove key", "cache.key2");
|
||
if (val) delete[] val;
|
||
test->Remove ("cache");
|
||
//test->Dump("cache");
|
||
val = test->Get ("cache", "key1");
|
||
if (sequencelogic::StrCmp (val, "value1") == 0)
|
||
rc += testfailed ("Remove table", "cache");
|
||
if (val) delete[] val;
|
||
test->ReKey (TestKey);
|
||
delete test;
|
||
|
||
#ifndef WIN32
|
||
test = new EyeEncryptedDB ("/test.db", badkey);
|
||
if (test->Put ("cache", "key2", "NewValue2"))
|
||
rc += testfailed ("UnCreated", "cache");
|
||
delete test;
|
||
#endif
|
||
if (rc == 0)
|
||
printf ("C++ DB tests passed\n");
|
||
|
||
// Test the C bindings
|
||
ionu_eyedb_put ("dbfile.db", TestKey, "collection", "key", "value");
|
||
ionu_eyedb_put ("dbfile.db", TestKey, "collection", "key2", "value2");
|
||
val = ionu_eyedb_get ("dbfile.db", TestKey, "collection", "key");
|
||
if (sequencelogic::StrCmp (val, "value") != 0)
|
||
rc += testfailed ("ionu_eyedb_get", "collection:key");
|
||
if (val) free (val);
|
||
ionu_eyedb_remove ("dbfile.db", TestKey, "collection", "key");
|
||
val = ionu_eyedb_get ("dbfile.db", TestKey, "collection", "key");
|
||
if (val)
|
||
rc += testfailed ("ionu_eyedb_remove", "collection:key");
|
||
ionu_eyedb_remove ("dbfile.db", TestKey, "collection", NULL);
|
||
val = ionu_eyedb_get ("dbfile.db", TestKey, "collection", "key2");
|
||
if (val)
|
||
rc += testfailed ("ionu_eyedb_remove", "collection");
|
||
if (rc)
|
||
printf ("%d db tests failed\n", rc);
|
||
else
|
||
printf ("DB tests passed\n");
|
||
return rc;
|
||
}
|
||
|
||
int TestDirectory()
|
||
{
|
||
printf ("\nDirectory tests\n-------------------------------\n");
|
||
int rc = 0;
|
||
/*
|
||
EyeDirectory* d = new EyeDirectory ("test", "*.ionu");
|
||
d->Dump();
|
||
d->Sort (EyeDirectory::ASCENDING_TIME);
|
||
d->Dump();
|
||
d->Sort (EyeDirectory::DESCENDING_TIME);
|
||
d->Dump();
|
||
d->Sort (EyeDirectory::ASCENDING_ALPHA);
|
||
d->Dump();
|
||
d->Sort (EyeDirectory::DESCENDING_ALPHA);
|
||
d->Dump();
|
||
size_t bytes = EyeDirectory::GetNumBytes ("test");
|
||
printf ("%ld bytes\n", (long int)bytes);
|
||
std::string f = d->GetFileName(5);
|
||
cout << "file 5: " << f << endl;
|
||
delete d;
|
||
d = new EyeDirectory ("test", "*.jk");
|
||
if (d->GetNumFiles() > 0)
|
||
rc += testfailed ("EyeDirectory(*.jk)", d->GetFileName(0));
|
||
delete d;
|
||
d = new EyeDirectory ("tst", "*.ionu");
|
||
if (d->GetNumFiles() > 0)
|
||
rc += testfailed ("EyeDirectory(tst/*.ionu)", d->GetFileName(0));
|
||
delete d;
|
||
d = new EyeDirectory ("test", "*.ion?");
|
||
delete d;
|
||
size_t i = 0;
|
||
size_t num = ionu_eyefile_list_directory_length ("garbage", "*.ionu");
|
||
char** list = ionu_eyefile_list_directory_sorted ("garbage", 0, num/2, "*.ionu", true);
|
||
for (i = 0; i<num/2; ++i) {
|
||
printf ("%s\n", list[i]);
|
||
free (list[i]);
|
||
}
|
||
if (list) free (list);
|
||
printf ("----------\n");
|
||
list = ionu_eyefile_list_directory_sorted ("test", num/2, num, "*.ionu", true);
|
||
if (list) {
|
||
for (i = 0; i<100; ++i) {
|
||
if (list[i]) {
|
||
printf ("%s\n", list[i]);
|
||
free (list[i]);
|
||
}
|
||
else
|
||
break;
|
||
}
|
||
free (list);
|
||
}
|
||
*/
|
||
return rc;
|
||
}
|
||
|
||
int TestJSON()
|
||
{
|
||
printf ("\nJSON tests\n-------------------------------\n");
|
||
int rc = 0;
|
||
std::string json;
|
||
unsigned char buff[2048];
|
||
char cbuff[2048];
|
||
EyeJSONObject* jtest = NULL;
|
||
EyeJSONObject* policies = NULL;
|
||
EyeJSONObject* policy = NULL;
|
||
jtest = new EyeJSONObject (NULL, JSON_OBJECT, NULL);
|
||
jtest->AddMember (new EyeJSONScalar ("id", "identifire", JSON_STRING));
|
||
jtest->AddMember (new EyeJSONScalar ("type", "rwlock", JSON_STRING));
|
||
jtest->GetJSONString(json);
|
||
delete jtest;
|
||
cout << json << std::endl;
|
||
|
||
const char* utfjson = "\\u0123\\u4567\\u89AB\\uCDEF\\uabcd\\uef4A ";
|
||
//const char* utfjson = "euro \\u20ac cent \\u00a2";
|
||
EyeJSONScalar* unicode = new EyeJSONScalar ("UTF-8", utfjson, JSON_STRING);
|
||
printf ("%s\n", utfjson);
|
||
sequencelogic::BinaryToHex ((unsigned char*)unicode->GetValue(), 16, cbuff);
|
||
printf ("%s\n", cbuff);
|
||
unicode->GetJSONString(json);
|
||
cout << json << std::endl;
|
||
if (sequencelogic::MemCmp (utfjson, json.c_str() + 9, 16) != 0) // Skip "UTF-8":"
|
||
rc += testfailed ("JSON", "UTF currency");
|
||
delete unicode;
|
||
jtest = new EyeJSONObject (NULL);
|
||
if (jtest->GetNumMembers() > 0 || jtest->GetMember ("policies"))
|
||
rc += testfailed ("JSON", "NULL");
|
||
delete jtest;
|
||
jtest = new EyeJSONObject ("");
|
||
if (jtest->GetNumMembers() > 0)
|
||
rc += testfailed ("JSON", "empty");
|
||
delete jtest;
|
||
jtest = new EyeJSONObject ("{}");
|
||
if (jtest->GetNumMembers() > 0)
|
||
rc += testfailed ("JSON", "empty{}");
|
||
delete jtest;
|
||
jtest = new EyeJSONObject ((char*)garbage);
|
||
if (jtest->GetNumMembers() > 0)
|
||
rc += testfailed ("JSON", "garbage");
|
||
delete jtest;
|
||
jtest = new EyeJSONObject ("[\"\"]");
|
||
if (jtest->GetNumMembers() != 1)
|
||
rc += testfailed ("JSON", "[\"\"]");
|
||
jtest->GetJSONString(json);
|
||
cout << json << std::endl;
|
||
delete jtest;
|
||
if (rc == 0)
|
||
printf ("PASSED: Bad json input data tests\n");
|
||
|
||
jtest = new EyeJSONObject (uploadedMeta);
|
||
jtest->GetJSONString(json);
|
||
cout << json << std::endl;
|
||
delete jtest;
|
||
jtest = new EyeJSONObject (someMeta);
|
||
jtest->GetJSONString(json);
|
||
cout << json << std::endl;
|
||
delete jtest;
|
||
jtest = new EyeJSONObject (policyTest);
|
||
jtest->GetJSONString(json);
|
||
cout << json << std::endl;
|
||
delete jtest;
|
||
jtest = new EyeJSONObject (vanishMeta);
|
||
jtest->GetJSONString(json);
|
||
cout << json << std::endl;
|
||
delete jtest;
|
||
jtest = new EyeJSONObject (badMeta);
|
||
jtest->GetJSONString(json);
|
||
cout << json << std::endl;
|
||
delete jtest;
|
||
|
||
FILE* fp = fopen ("test/test.json", "r");
|
||
char fbuff[104668];
|
||
size_t by = fread (fbuff, 1, 2048, fp);
|
||
fbuff[by] = '\0';
|
||
//printf ("%d\n<%s>\n", int(by), fbuff);
|
||
jtest = new EyeJSONObject (fbuff);
|
||
jtest->GetJSONString(json);
|
||
if (json.length() > 0)
|
||
cout << json << std::endl;
|
||
else
|
||
rc += testfailed ("JSON", "coverage test");
|
||
delete jtest;
|
||
fclose (fp);
|
||
|
||
fp = fopen ("test/huge.json", "r");
|
||
by = fread (fbuff, 1, 104663, fp);
|
||
fbuff[by] = '\0';
|
||
//printf ("%d\n<%s>\n", int(by), fbuff);
|
||
jtest = new EyeJSONObject (fbuff);
|
||
jtest->GetJSONString(json);
|
||
if (json.length() < 3)
|
||
testfailed ("JSON", "huge test");
|
||
else
|
||
printf ("test/huge.json = %d bytes\n", (int)(json.length()));
|
||
delete jtest;
|
||
fclose (fp);
|
||
|
||
jtest = new EyeJSONObject (JSON);
|
||
policies = dynamic_cast<EyeJSONObject*>(jtest->GetMember ("policies"));
|
||
if (policies) {
|
||
policies->GetJSONString(json);
|
||
cout << json << std::endl;
|
||
}
|
||
delete jtest;
|
||
jtest = new EyeJSONObject (policyTest);
|
||
policies = dynamic_cast<EyeJSONObject*>(jtest->GetMember ("policies"));
|
||
if (policies) {
|
||
for (size_t i = 0; i < policies->GetNumMembers(); ++i) {
|
||
policy = dynamic_cast<EyeJSONObject*>(policies->GetMember (i));
|
||
EyeJSONNode* item = policy->GetMember("policyName");
|
||
if (item) {
|
||
item->GetJSONString(json);
|
||
cout << json << std::endl;
|
||
}
|
||
item = policy->GetMember("policyValue");
|
||
if (item) {
|
||
item->GetJSONString(json);
|
||
cout << json << std::endl;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
rc++;
|
||
delete jtest;
|
||
|
||
printf ("\nPolicy tests\n-------------------------------\n");
|
||
ionu_policy_install (NULL);
|
||
ionu_policy_install ("");
|
||
ionu_policy_install ((char*)garbage);
|
||
ionu_policy_install (policyTest);
|
||
char* policychk = ionu_policy_check ("allowUserPasswordChange");
|
||
if (policychk) {
|
||
printf ("%s\n", policychk);
|
||
free (policychk);
|
||
}
|
||
else
|
||
rc += testfailed ("PolicyCheck", "allowUserPasswordChange");
|
||
|
||
policychk = ionu_policy_check ("cachedTGIKeysExpire");
|
||
if (policychk) {
|
||
EyeJSONObject* expire = new EyeJSONObject (policychk);
|
||
EyeJSONScalar* pval = dynamic_cast<EyeJSONScalar*>(expire->GetMember("policyValue"));
|
||
if (pval)
|
||
printf ("Cached keys expire in %sms\n", pval->GetValue());
|
||
else
|
||
rc += testfailed ("PolicyCheck", "cachedTGIKeysExpire no value found");
|
||
delete expire;
|
||
free (policychk);
|
||
}
|
||
else
|
||
rc += testfailed ("PolicyCheck", "cachedTGIKeysExpire");
|
||
|
||
// Check for policy that is not there
|
||
policychk = ionu_policy_check ("allowStupidPasswords");
|
||
if (policychk) {
|
||
rc += testfailed ("PolicyCheck", "allowStupidPasswords");
|
||
free (policychk);
|
||
}
|
||
ionu_policy_check (NULL);
|
||
ionu_policy_check ("");
|
||
ionu_policy_check ((char*)garbage);
|
||
ionu_policy_uninstall ();
|
||
|
||
// Check with no policies installed
|
||
policychk = ionu_policy_check ("allowUserPasswordChange");
|
||
if (policychk) {
|
||
rc += testfailed ("PolicyCheck", "uninstalled");
|
||
free (policychk);
|
||
}
|
||
/*
|
||
printf ("\ncompute_keys tests\n-------------------------------\n");
|
||
FILE* jp = fopen ("test/collab100.json", "r");
|
||
char* jbuff = new (char[1024*1024]);
|
||
by = fread (jbuff, 1, 592693, jp);
|
||
fclose (jp);
|
||
jbuff[by] = '\0';
|
||
//char* j = ionu_compute_keys ("[\"urn:sl:000000:1A537720::\",\"urn:sl:000000:D676E999::\"]", jbuff);
|
||
//if (j) free (j);
|
||
delete[] jbuff;
|
||
//ionu_compute_keys (NULL, collabs);
|
||
//ionu_compute_keys ("", collabs);
|
||
//ionu_compute_keys ((char*)garbage, collabs);
|
||
//ionu_compute_keys (members, NULL);
|
||
//ionu_compute_keys (members, "");
|
||
//ionu_compute_keys (members, (char*)garbage);
|
||
jtest = new EyeJSONObject (members);
|
||
delete jtest;
|
||
jtest = new EyeJSONObject (collabs);
|
||
delete jtest;
|
||
j = ionu_compute_keys (members, collabs);
|
||
EyeJSONObject* collabtest = new EyeJSONObject(collabs);
|
||
EyeJSONObject* membertest = new EyeJSONObject(members);
|
||
std::string c2;
|
||
collabtest->GetJSONString(c2);
|
||
std::string m2;
|
||
membertest->GetJSONString(m2);
|
||
//char* j2 = ionu_compute_keys (m2.c_str(), c2.c_str());
|
||
cout << "Random" << endl;
|
||
cout << j2 << endl;
|
||
//if (strcmp (c2, collabs) != 0)
|
||
// printf ("FAILED:\n%s\n%s\n", collabs, c2);
|
||
//if (strcmp (m2, members) != 0)
|
||
// printf ("FAILED:\n%s\n%s\n", members, m2);
|
||
delete collabtest;
|
||
delete membertest;
|
||
|
||
Key* privateKey = new Key ("Check", "compute_keys", "test/private_key.pem", "");
|
||
EyeJSONObject* keys = new EyeJSONObject(j);
|
||
keys->GetJSONString(m2);
|
||
if (sequencelogic::StrCmp (m2.c_str(), j) != 0)
|
||
rc += testfailed ("compute_keysi j != m2", m2.c_str());
|
||
for (size_t i = 0; i < keys->GetNumMembers(); ++i) {
|
||
EyeJSONObject* userkey = dynamic_cast<EyeJSONObject*>(keys->GetMember(i));
|
||
EyeJSONScalar* enkey = dynamic_cast<EyeJSONScalar*>(userkey->GetMember("key"));
|
||
Base64Decode (enkey->GetValue(), buff);
|
||
size_t bytes = 256;
|
||
unsigned char* back = privateKey->PrivateKeyDecrypt (buff, bytes, &bytes);
|
||
sequencelogic::Base64Encode (back, SL_AES_KEY_LEN, cbuff);
|
||
printf ("decrypt TGI %d: %s\n", (int)bytes, cbuff);
|
||
delete[] back;
|
||
}
|
||
free (j);
|
||
free (j2);
|
||
delete keys;
|
||
sequencelogic::Base64Encode (TGIkey, SL_AES_KEY_LEN, cbuff);
|
||
printf ("TGI: %s\n", cbuff);
|
||
j2 = ionu_recompute_keys (m2.c_str(), c2.c_str(), TGIkey);
|
||
cout << j2 << endl;
|
||
keys = new EyeJSONObject(j2);
|
||
keys->GetJSONString(m2);
|
||
for (size_t i = 0; i < keys->GetNumMembers(); ++i) {
|
||
EyeJSONObject* userkey = dynamic_cast<EyeJSONObject*>(keys->GetMember(i));
|
||
EyeJSONScalar* enkey = dynamic_cast<EyeJSONScalar*>(userkey->GetMember("key"));
|
||
Base64Decode (enkey->GetValue(), buff);
|
||
size_t bytes = 256;
|
||
unsigned char* back = privateKey->PrivateKeyDecrypt (buff, bytes, &bytes);
|
||
sequencelogic::Base64Encode (back, SL_AES_KEY_LEN, cbuff);
|
||
printf ("decrypt TGI %d: %s\n", (int)bytes, cbuff);
|
||
delete[] back;
|
||
}
|
||
free (j2);
|
||
delete keys;
|
||
delete privateKey;
|
||
*/
|
||
return rc;
|
||
}
|
||
|
||
int TestTime()
|
||
{
|
||
int rc = 0;
|
||
EyeTime t;
|
||
const char* tstr = t.GetISO8601Time();
|
||
printf ("Current time %s\n", tstr);
|
||
EyeTime nt(tstr);
|
||
const char* ntstr = nt.GetISO8601Time();
|
||
if (strcmp (tstr, ntstr) != 0)
|
||
rc += testfailed ("EyeTime", ntstr);
|
||
tstr = t.GetISO8601TimeMs();
|
||
printf ("Current time %s\n", tstr);
|
||
nt.SetTime (tstr);
|
||
ntstr = nt.GetISO8601TimeMs();
|
||
if (strcmp (tstr, ntstr) != 0)
|
||
rc += testfailed ("EyeTime", ntstr);
|
||
tstr = t.GetUnixTime();
|
||
printf ("Current time %s\n", tstr);
|
||
t.SetTime ("2014-01-23T17:44:40Z");
|
||
printf ("Seconds from now %0.0f\n", t.SecondsFromNow());
|
||
t.SetTime ("2014-01-23T17:45:40Z");
|
||
printf ("Seconds from now %0.0f\n", t.SecondsFromNow());
|
||
t.SetTime ("2014-03-07T09:31:17U");
|
||
printf ("2014-03-07T09:31:17U %s\n", t.GetUnixTime());
|
||
t.SetTime ("2014-03-07T10:18:37U");
|
||
printf ("2014-03-07T10:18:37U %s\n", t.GetUnixTime());
|
||
printf ("%s\n", t.GetISO8601Time ());
|
||
printf ("%s\n", t.GetLocalISO8601Time ());
|
||
printf ("%s\n", t.GetISO8601Time ());
|
||
|
||
t.SetTime ("2014-03-06T00:31:17Z");
|
||
tstr = t.GetUnixTime();
|
||
if (strcmp (tstr, "1394065877") != 0)
|
||
rc += testfailed ("EyeTime", tstr);
|
||
t.Dump();
|
||
|
||
// Test various leap years over a range of time
|
||
t.SetTime ("2006-01-31T01:31:17Z");
|
||
if (strcmp (t.GetISO8601Time(), "2006-01-31T01:31:17Z") != 0)
|
||
rc += testfailed ("EyeTime", t.GetISO8601Time());
|
||
t.SetTime ("2006-02-29T01:32:17Z");
|
||
if (strcmp (t.GetISO8601Time(), "2006-02-29T01:32:17Z") != 0)
|
||
rc += testfailed ("EyeTime", t.GetISO8601Time());
|
||
t.SetTime ("2006-06-08T01:33:17Z");
|
||
if (strcmp (t.GetISO8601Time(), "2006-06-08T01:33:17Z") != 0)
|
||
rc += testfailed ("EyeTime", t.GetISO8601Time());
|
||
t.SetTime ("2006-12-08T01:34:17Z");
|
||
if (strcmp (t.GetISO8601Time(), "2006-12-08T01:34:17Z") != 0)
|
||
rc += testfailed ("EyeTime", t.GetISO8601Time());
|
||
|
||
t.SetTime ("2010-01-31T01:31:17Z");
|
||
if (strcmp (t.GetISO8601Time(), "2010-01-31T01:31:17Z") != 0)
|
||
rc += testfailed ("EyeTime", t.GetISO8601Time());
|
||
t.SetTime ("2010-06-08T01:32:17Z");
|
||
if (strcmp (t.GetISO8601Time(), "2010-06-08T01:32:17Z") != 0)
|
||
rc += testfailed ("EyeTime", t.GetISO8601Time());
|
||
t.SetTime ("2010-12-08T01:33:17Z");
|
||
if (strcmp (t.GetISO8601Time(), "2010-12-08T01:33:17Z") != 0)
|
||
rc += testfailed ("EyeTime", t.GetISO8601Time());
|
||
|
||
t.SetTime ("2014-01-31T01:31:17Z");
|
||
if (strcmp (t.GetISO8601Time(), "2014-01-31T01:31:17Z") != 0)
|
||
rc += testfailed ("EyeTime", t.GetISO8601Time());
|
||
t.SetTime ("2014-02-28T01:32:17Z");
|
||
if (strcmp (t.GetISO8601Time(), "2014-02-28T01:32:17Z") != 0)
|
||
rc += testfailed ("EyeTime", t.GetISO8601Time());
|
||
t.SetTime ("2014-02-29T01:33:17Z");
|
||
if (strcmp (t.GetISO8601Time(), "2014-02-29T01:33:17Z") != 0)
|
||
rc += testfailed ("EyeTime", t.GetISO8601Time());
|
||
t.SetTime ("2014-06-08T01:34:17Z");
|
||
if (strcmp (t.GetISO8601Time(), "2014-06-08T01:34:17Z") != 0)
|
||
rc += testfailed ("EyeTime", t.GetISO8601Time());
|
||
t.SetTime ("2014-12-08T01:35:17Z");
|
||
if (strcmp (t.GetISO8601Time(), "2014-12-08T01:35:17Z") != 0)
|
||
rc += testfailed ("EyeTime", t.GetISO8601Time());
|
||
|
||
// Most recent leap second, June 30, 2012 at 23:59:60
|
||
t.SetTime ("2012-06-30T23:59:60Z");
|
||
if (strcmp (t.GetISO8601Time(), "2012-06-30T23:59:60Z") != 0)
|
||
rc += testfailed ("EyeTime", t.GetISO8601Time());
|
||
|
||
// Invalid dates and times
|
||
t.SetTime ("2013-02-29T01:31:17Z");
|
||
if (strcmp (t.GetISO8601Time(), "2014-02-29T01:31:17Z") == 0)
|
||
rc += testfailed ("EyeTime", t.GetISO8601Time());
|
||
t.SetTime ("2013-04-31T01:31:17Z");
|
||
if (strcmp (t.GetISO8601Time(), "2014-04-31T01:31:17Z") == 0)
|
||
rc += testfailed ("EyeTime", t.GetISO8601Time());
|
||
t.SetTime ("2013-02-28T24:31:17Z");
|
||
if (strcmp (t.GetISO8601Time(), "2014-02-28T24:31:17Z") == 0)
|
||
rc += testfailed ("EyeTime", t.GetISO8601Time());
|
||
t.SetTime ("2013-02-28T14:71:17Z");
|
||
if (strcmp (t.GetISO8601Time(), "2014-02-28T14:71:17Z") == 0)
|
||
rc += testfailed ("EyeTime", t.GetISO8601Time());
|
||
t.SetTime ("2013-02-28T14:31:77Z");
|
||
if (strcmp (t.GetISO8601Time(), "2014-02-28T14:31:77Z") == 0)
|
||
rc += testfailed ("EyeTime", t.GetISO8601Time());
|
||
|
||
t.SetTime ("2014-06-08T01:31:17.777Z");
|
||
t.Dump();
|
||
t.SetTime ("2014-06-14T01:31:17.777Z");
|
||
t.Dump();
|
||
t.SetTime ("2013-03-01T01:31:17.777Z");
|
||
t.Dump();
|
||
t.SetTime ("2012-03-01T01:31:17.555M");
|
||
t.Dump();
|
||
t.SetTime ("2012-06-11T01:31:17.333Y");
|
||
t.Dump();
|
||
|
||
t.SetTime ("2014-10-28T23:13:06.174Z");
|
||
cout << t << endl;
|
||
t.SetFileTime ("t");
|
||
t.GetFileTime ("t");
|
||
cout << t << endl;
|
||
t.SetTime ("2014-11-17T15:14:56-07:00");
|
||
cout << t << endl;
|
||
t.SetTime ("2014-11-17T15:14:56+07:00");
|
||
cout << t << endl;
|
||
t.SetTime ("2014-11-17T16:14:56-08:00");
|
||
cout << t << endl;
|
||
//t.SetTime ("2008-04-10 13:30:00Z");
|
||
//cout << t << endl;
|
||
//t.SetTime ("Thu, 10 Apr 2008 13:30:00 GMT");
|
||
//cout << t << endl;
|
||
//t.SetTime ("Thursday, April 10, 2008 1:30:00 PM");
|
||
//cout << t << endl;
|
||
//t.SetTime ("6/15/2009 1:45:30 PM");
|
||
//cout << t << endl;
|
||
//t.SetTime ("6/15/2009 1:45:30 PM -07:00");
|
||
//cout << t << endl;
|
||
//t.SetTime ("4/10/2008 6:30:00 AM");
|
||
//cout << t << endl;
|
||
|
||
t.SetTime ("808464430-67--858993460T58:128:00.000C");
|
||
printf ("%s\n", t.GetISO8601TimeMs ());
|
||
cout << t << endl;
|
||
t.Dump();
|
||
|
||
t.SetTime ("2014-06-08T01:31:17.777Z");
|
||
if (rc == 0)
|
||
printf ("\nEyeTime tests passed\n-------------------------------\n");
|
||
else
|
||
printf ("\n%d EyeTime tests failed\n-------------------------------\n", rc);
|
||
return rc;
|
||
}
|
||
|
||
int TestUtils()
|
||
{
|
||
int rc = 0;
|
||
printf ("\nUtility tests\n-------------------------------\n");
|
||
char* md = NULL;
|
||
unsigned char cg_key[SL_AES_KEY_LEN];
|
||
unsigned char user_key[SL_AES_KEY_LEN];
|
||
ionu_derive_key ("u3K2*l$qZ0a<", cg_key);
|
||
ionu_derive_userkey ("u3K2*l$qZ0a<", user_key, cg_key);
|
||
|
||
unsigned char binary[64] = {211,231,210,248,235};
|
||
unsigned char utf8[10] = {0x20, 0xc2,0xa2, 0xe2,0x82,0xac, 0xf0,0xa4,0xad,0xa2};
|
||
if (sequencelogic::IsStrUTF8 ((char*)cg_key, SL_AES_KEY_LEN))
|
||
rc += testfailed ("sequencelogic::IsStrUTF8", "cg_key");
|
||
if (!sequencelogic::IsStrUTF8 ((char*)utf8, 10))
|
||
rc += testfailed ("sequencelogic::IsStrUTF8", "valid currency symbols");
|
||
char ascii[256];
|
||
size_t bytes = 0;
|
||
//sequencelogic::DumpAsBinary (binary, 5);
|
||
//sequencelogic::Base32Encode (binary, 1, ascii);
|
||
//printf ("%s\n", ascii);
|
||
//sequencelogic::Base32Encode (binary, 2, ascii);
|
||
//printf ("%s\n", ascii);
|
||
//sequencelogic::Base32Encode (binary, 3, ascii);
|
||
//printf ("%s\n", ascii);
|
||
//sequencelogic::Base32Encode (binary, 4, ascii);
|
||
//printf ("%s\n", ascii);
|
||
//sequencelogic::Base32Encode (binary, 5, ascii);
|
||
//printf ("%s\n", ascii);
|
||
//bytes = sequencelogic::Base32Decode (ascii, binary);
|
||
//sequencelogic::DumpAsBinary (binary, 5);
|
||
|
||
sequencelogic::Base32Encode (cg_key, 15, ascii);
|
||
bytes = sequencelogic::Base32Decode (ascii, binary);
|
||
if (bytes != 15 || sequencelogic::MemCmp (binary, cg_key, 15) != 0)
|
||
rc += testfailed ("B32 15 bytes cg_key", ascii);
|
||
sequencelogic::Base32Encode (cg_key, SL_AES_KEY_LEN, ascii);
|
||
bytes = sequencelogic::Base32Decode (ascii, binary);
|
||
if (bytes != SL_AES_KEY_LEN || sequencelogic::MemCmp (binary, cg_key, SL_AES_KEY_LEN) != 0)
|
||
rc += testfailed ("B32 cg_key", ascii);
|
||
|
||
sequencelogic::Base32Encode (user_key, 15, ascii);
|
||
bytes = sequencelogic::Base32Decode (ascii, binary);
|
||
if (bytes != 15 || sequencelogic::MemCmp (binary, user_key, 15) != 0)
|
||
rc += testfailed ("B32 15 bytes user_key", ascii);
|
||
sequencelogic::Base32Encode (user_key, SL_AES_KEY_LEN, ascii);
|
||
bytes = sequencelogic::Base32Decode (ascii, binary);
|
||
if (bytes != SL_AES_KEY_LEN || sequencelogic::MemCmp (binary, user_key, SL_AES_KEY_LEN) != 0)
|
||
rc += testfailed ("B32 user_key", ascii);
|
||
if (rc == 0)
|
||
printf ("Base32 tests passed\n");
|
||
|
||
sequencelogic::Base64Encode (cg_key, 15, ascii);
|
||
bytes = sequencelogic::Base64Decode (ascii, binary);
|
||
if (bytes != 15 || sequencelogic::MemCmp (binary, cg_key, 15) != 0)
|
||
rc += testfailed ("B64 15 bytes cg_key", ascii);
|
||
sequencelogic::Base64Encode (cg_key, SL_AES_KEY_LEN, ascii);
|
||
bytes = sequencelogic::Base64Decode (ascii, binary);
|
||
if (bytes != SL_AES_KEY_LEN || sequencelogic::MemCmp (binary, cg_key, SL_AES_KEY_LEN) != 0)
|
||
rc += testfailed ("B64 cg_key", ascii);
|
||
|
||
sequencelogic::Base64Encode (user_key, 15, ascii);
|
||
bytes = sequencelogic::Base64Decode (ascii, binary);
|
||
if (bytes != 15 || sequencelogic::MemCmp (binary, user_key, 15) != 0)
|
||
rc += testfailed ("B64 15 bytes user_key", ascii);
|
||
sequencelogic::Base64Encode (user_key, SL_AES_KEY_LEN, ascii);
|
||
bytes = sequencelogic::Base64Decode (ascii, binary);
|
||
if (bytes != SL_AES_KEY_LEN || sequencelogic::MemCmp (binary, user_key, SL_AES_KEY_LEN) != 0)
|
||
rc += testfailed ("B64 user_key", ascii);
|
||
if (rc == 0)
|
||
printf ("Base64 tests passed\n");
|
||
|
||
ionu_base64_encode (cg_key, 15, ascii);
|
||
bytes = ionu_base64_decode (ascii, binary);
|
||
if (bytes != 15 || sequencelogic::MemCmp (binary, cg_key, 15) != 0)
|
||
rc += testfailed ("ionu_B64 15 bytes cg_key", ascii);
|
||
|
||
// Test TGI signature generation
|
||
/*
|
||
if (ionu_gen_tgisig (NULL))
|
||
rc += testfailed ("GenerateTGISig", "NULLempty");
|
||
if (ionu_gen_tgisig (""))
|
||
rc += testfailed ("GenerateTGISig", "empty");
|
||
if (ionu_gen_tgisig ((char*)garbage))
|
||
rc += testfailed ("GenerateTGISig", "garbage");
|
||
md = ionu_gen_tgisig (PERMS);
|
||
if (rc == 0 && sequencelogic::StrCmp (md, "6a0ce1ec504b") == 0)
|
||
printf ("TGI signature tests passed: %s\n", md);
|
||
else
|
||
rc += testfailed ("TGI signature\n", md);
|
||
free (md);
|
||
*/
|
||
md = ionu_digest_msg ("sha1", (const unsigned char*)PERMS, strlen(PERMS));
|
||
if (sequencelogic::StrCmp (md, "03b00bb4cc0edc80b9063653c8340a908775a367") != 0)
|
||
rc += testfailed ("sha1", md);
|
||
free (md);
|
||
md = ionu_digest_msg ("sha256", (const unsigned char*)PERMS, strlen(PERMS));
|
||
if (sequencelogic::StrCmp (md, "27d80a5effacb099f49ba81a245ad4a4ea0c3e1768b3b2a7d6833365c66be8fa") != 0)
|
||
rc += testfailed ("sha256", md);
|
||
free (md);
|
||
|
||
std::string hmd;
|
||
hmd = sequencelogic::HMACMessage (NULL, SL_AES_KEY_LEN, (const unsigned char*)PERMS, strlen(PERMS));
|
||
if (hmd.size() > 0)
|
||
rc += testfailed ("hmac", "NULL key");
|
||
hmd = sequencelogic::HMACMessage (TestKey, SL_AES_KEY_LEN, NULL, strlen(PERMS));
|
||
if (hmd.size() > 0)
|
||
rc += testfailed ("hmac", "NULL msg");
|
||
hmd = sequencelogic::HMACMessage (TestKey, SL_AES_KEY_LEN/2, (const unsigned char*)PERMS, strlen(PERMS));
|
||
if (hmd.compare ("42963870f70684f00ebe8d083f61f20a87265ff4") != 0)
|
||
rc += testfailed ("hmac cg_key/2", hmd.c_str());
|
||
hmd = sequencelogic::HMACMessage (TestKey, SL_AES_KEY_LEN, (const unsigned char*)shortword, strlen(shortword));
|
||
if (hmd.compare ("f160e4c65719db3bbcfe9bf00cd3cedda078a3dd") != 0)
|
||
rc += testfailed ("hmac cg_key Hi", hmd.c_str());
|
||
hmd = sequencelogic::HMACMessage (TestKey, SL_AES_KEY_LEN, (const unsigned char*)PERMS, strlen(PERMS));
|
||
if (hmd.compare ("a06df1aacfbf923b8053773dec8b7529467faaab") != 0)
|
||
rc += testfailed ("hmac cg_key", hmd.c_str());
|
||
hmd = sequencelogic::HMACMessage (badkey, SL_AES_KEY_LEN, (const unsigned char*)PERMS, strlen(PERMS));
|
||
if (hmd.compare ("c59d3a08989ffd2d30b05815d68a240d526fa49f") != 0)
|
||
rc += testfailed ("hmac user_key", hmd.c_str());
|
||
if (rc == 0)
|
||
printf ("Hash and HMAC tests passed\n");
|
||
|
||
//size_t len = 0;
|
||
//unsigned char* enc = ionu_symmetric_encrypt_buffer (TGIkey, (const unsigned char*) "Howdy", 6, &len, badkey);
|
||
//unsigned char* dec = ionu_symmetric_decrypt_buffer (TGIkey, enc, len, &len, badkey);
|
||
//if (sequencelogic::StrCmp ((char*)dec, "Howdy") != 0)
|
||
// rc += testfailed ("ionu_symmetric_decrypt_buffer", "Howdy");
|
||
//free (enc);
|
||
//free (dec);
|
||
|
||
|
||
// Test URN validation
|
||
if (! CheckURN (URN))
|
||
rc += testfailed ("IsValidURN", URN);
|
||
if (! CheckURN (URN0))
|
||
rc += testfailed ("IsValidURN", URN0);
|
||
if (! CheckURN (URN1))
|
||
rc += testfailed ("IsValidURN", URN1);
|
||
if (! CheckURN (URN2))
|
||
rc += testfailed ("IsValidURN", URN2);
|
||
if (! CheckURN (URN3))
|
||
rc += testfailed ("IsValidURN", URN3);
|
||
if (! CheckURN (URN4))
|
||
rc += testfailed ("IsValidURN", URN4);
|
||
if (! CheckURN (URN5))
|
||
rc += testfailed ("IsValidURN", URN5);
|
||
|
||
if (rc == 0)
|
||
printf ("Valid URN tests passed\n");
|
||
|
||
if (sequencelogic::IsValidURN (NULL))
|
||
rc += testfailed ("IsValidURN", "NULL");
|
||
if (sequencelogic::IsValidURN (""))
|
||
rc += testfailed ("IsValidURN", "empty");
|
||
if (sequencelogic::IsValidURN ((char*)garbage))
|
||
rc += testfailed ("IsValidURN", "garbage");
|
||
|
||
if (sequencelogic::IsValidURN (burn0))
|
||
rc += testfailed ("IsValidURN", burn0);
|
||
if (sequencelogic::IsValidURN (burn1))
|
||
rc += testfailed ("IsValidURN", burn1);
|
||
if (sequencelogic::IsValidURN (burn2))
|
||
rc += testfailed ("IsValidURN", burn2);
|
||
if (sequencelogic::IsValidURN (burn3))
|
||
rc += testfailed ("IsValidURN", burn3);
|
||
if (sequencelogic::IsValidURN (burn4))
|
||
rc += testfailed ("IsValidURN", burn4);
|
||
if (sequencelogic::IsValidURN (burn5))
|
||
rc += testfailed ("IsValidURN", burn5);
|
||
if (sequencelogic::IsValidURN (burn6))
|
||
rc += testfailed ("IsValidURN", burn6);
|
||
if (sequencelogic::IsValidURN (burn7))
|
||
rc += testfailed ("IsValidURN", burn7);
|
||
if (rc == 0)
|
||
printf ("Invalid URN tests passed\n");
|
||
|
||
// Test URI encode and decode
|
||
//EyeBytes url;
|
||
//url.AssignURIEncodedString(cgurl);
|
||
//char* uri = url.GetURIEncodedString();
|
||
//if (sequencelogic::StrCmp (cgurl, uri) != 0)
|
||
// rc += testfailed ("URI encoding", uri);
|
||
//delete[] uri;
|
||
|
||
Key bkey ("Meta", "key", SL_AES_KEY_LEN, badkey, Key::AES);
|
||
std::string encfstr = sequencelogic::EncryptFilename (".imchat", bkey);
|
||
encfstr = sequencelogic::DecryptFilename (encfstr, bkey);
|
||
if (encfstr.compare (".imchat") != 0)
|
||
rc += testfailed ("sequencelogic::DecryptFilename(.imchat)", "");
|
||
|
||
#ifdef WIN32
|
||
std::string f1 ("C:\\Users\\philip\\Dropbox\\New Text Document.txt.ionu");
|
||
std::string f2 ("C:\\Users\\philip\\Dropbox\\NEW TEXT DOCUMENT.txt.ionu");
|
||
if (sequencelogic::CompareFilenames (f1, f2) != 0)
|
||
rc += testfailed ("sequencelogic::sequencelogic::CompareFilenames", "New Text Document");
|
||
#endif
|
||
cout << "test.ai " << sequencelogic::GuessMimeType ("test.ai") << endl;
|
||
cout << "test.doc " << sequencelogic::GuessMimeType ("test.doc") << endl;
|
||
cout << "test.gzip " << sequencelogic::GuessMimeType ("test.gzip") << endl;
|
||
cout << "test.docx " << sequencelogic::GuessMimeType ("test.docx") << endl;
|
||
cout << "test.ionu " << sequencelogic::GuessMimeType ("test.ionu") << endl;
|
||
cout << "test.jpeg " << sequencelogic::GuessMimeType ("test.jpeg") << endl;
|
||
cout << "test.json " << sequencelogic::GuessMimeType ("test.json") << endl;
|
||
cout << "test.m4a " << sequencelogic::GuessMimeType ("test.m4a") << endl;
|
||
cout << "test.pdf " << sequencelogic::GuessMimeType ("test.pdf") << endl;
|
||
cout << "test.qt " << sequencelogic::GuessMimeType ("test.qt") << endl;
|
||
cout << "test.cer " << sequencelogic::GuessMimeType ("test.cer") << endl;
|
||
cout << "test.crt " << sequencelogic::GuessMimeType ("test.crt") << endl;
|
||
cout << "test.ionu " << sequencelogic::GuessMimeType ("test.ionu") << endl;
|
||
cout << "test.wav " << sequencelogic::GuessMimeType ("test.wav") << endl;
|
||
cout << "test.g " << sequencelogic::GuessMimeType ("test.g") << endl;
|
||
cout << "test. " << sequencelogic::GuessMimeType ("test.") << endl;
|
||
cout << "test " << sequencelogic::GuessMimeType ("test") << endl;
|
||
|
||
return rc;
|
||
}
|
||
|
||
int TestRandom()
|
||
{
|
||
std::string pw ("");
|
||
unsigned char buff[32768];
|
||
EyeDRBG* drbg = new EyeDRBG ((unsigned char*)"000000:tim,favbook::BOB,flame::BOB,kiss::BOB]", strlen ("000000:tim,favbook::BOB,flame::BOB,kiss::BOB]"));
|
||
drbg->RandBytes (buff, 4096);
|
||
ofstream file ("drbg", ios::out | ios::binary | ios::trunc);
|
||
if (file.is_open()) {
|
||
file.write ((char*)buff, 4096);
|
||
file.close();
|
||
}
|
||
delete drbg;
|
||
#ifdef ENTROPY_VALIDATION
|
||
// Create 3 different files with 4096 bytes of "random" data. The program "ent" can be used to
|
||
// analyze these using statistical techniques for randomness.
|
||
drbg = new EyeDRBG ((unsigned char*)"ALANRENOTOBYKEITH", strlen ("ALANRENOTOBYKEITH"));
|
||
drbg->RandBytes (buff, 4096);
|
||
ofstream nfile ("drbg1", ios::out | ios::binary | ios::trunc);
|
||
if (nfile.is_open()) {
|
||
nfile.write ((char*)buff, 4096);
|
||
nfile.close();
|
||
}
|
||
delete drbg;
|
||
sequencelogic::RandomBytes (buff, 4096);
|
||
ofstream rfile ("rand", ios::out | ios::binary | ios::trunc);
|
||
if (rfile.is_open()) {
|
||
rfile.write ((char*)buff, 4096);
|
||
rfile.close();
|
||
}
|
||
#endif
|
||
|
||
// Generate 8 base32 and base64 passwords
|
||
size_t i = 0;
|
||
printf ("Base32: ");
|
||
for (i = 0; i < 8; ++i) {
|
||
pw = RandomBase32 (8);
|
||
printf ("%s ", pw.c_str());
|
||
}
|
||
printf ("\nBase64: ");
|
||
for (i = 0; i < 8; ++i) {
|
||
pw = RandomBase64 (8);
|
||
printf ("%s ", pw.c_str());
|
||
}
|
||
printf ("\nSimple: ");
|
||
for (i = 0; i < 8; ++i) {
|
||
pw = RandomPassWord (8, passwordset);
|
||
printf ("%s ", pw.c_str());
|
||
}
|
||
printf ("\nBest: ");
|
||
for (i = 0; i < 6; ++i) {
|
||
pw = RandomPassWord (10, NULL);
|
||
printf ("%s ", pw.c_str());
|
||
}
|
||
printf ("\n");
|
||
return 0;
|
||
}
|
||
|
||
int TestRSAKeyGeneration()
|
||
{
|
||
Key rkey;
|
||
Keyring ring ("RSA", "tests");
|
||
ring.GenerateRSAKey ("challenges", "test to match JS implementation", challenges);
|
||
ring.GetKey ("challenges", rkey);
|
||
cout << rkey.GetPubKey() << endl;
|
||
ring.GenerateRSAKey ("challenges1", "test to match JS implementation", challenges1);
|
||
ring.GetKey ("challenges1", rkey);
|
||
cout << rkey.GetPubKey() << endl;
|
||
ring.GenerateRSAKey ("challenges2", "test to match JS implementation", challenges2);
|
||
ring.GetKey ("challenges2", rkey);
|
||
cout << rkey.GetPubKey() << endl;
|
||
ring.GenerateRSAKey ("IOnUBob", "test to match JS implementation", "IOnU,Bob,Bob,Bob");
|
||
ring.GetKey ("IOnUBob", rkey);
|
||
cout << rkey.PublicKeyFingerPrint() << endl;
|
||
ring.GenerateRSAKey ("IONUBob", "test to match JS implementation", "IONU,Bob,Bob,Bob");
|
||
ring.GetKey ("IONUBob", rkey);
|
||
cout << rkey.PublicKeyFingerPrint() << endl;
|
||
#ifndef WIN32
|
||
std::vector<std::string> answers;
|
||
for (size_t i = 0; i < 10; ++i) {
|
||
size_t pos = rand() &0x000F;
|
||
std::string challengeResponse = challengeQuestions[pos];
|
||
challengeResponse += ":";
|
||
challengeResponse += challengeAnswers[pos];
|
||
answers.push_back (challengeResponse);
|
||
pos = rand() &0x000F;
|
||
challengeResponse = challengeQuestions[pos];
|
||
challengeResponse += ":";
|
||
challengeResponse += challengeAnswers[pos];
|
||
answers.push_back (challengeResponse);
|
||
pos = rand() &0x000F;
|
||
challengeResponse = challengeQuestions[pos];
|
||
challengeResponse += ":";
|
||
challengeResponse += challengeAnswers[pos];
|
||
answers.push_back (challengeResponse);
|
||
|
||
std::sort (answers.begin(), answers.end());
|
||
challengeResponse = "[\"IOnU\",";
|
||
for (string &answer : answers) {
|
||
challengeResponse += "\"";
|
||
challengeResponse += answer;
|
||
}
|
||
challengeResponse += "\"]";
|
||
cout << challengeResponse << endl;
|
||
answers.clear();
|
||
//ring.GenerateRSAKey ("RSA", "", challengeResponse);
|
||
}
|
||
#endif
|
||
return 0;
|
||
}
|
||
|
||
int TestKeys()
|
||
{
|
||
int rc = 0;
|
||
unsigned char* pbuff = NULL;
|
||
Key* k = NULL;
|
||
size_t bytes = 0;
|
||
unsigned char* back = NULL;
|
||
|
||
printf ("\nKeyring tests\n-------------------------------\n");
|
||
const char* goodword = "password";
|
||
const char* badword = "wrong";
|
||
unsigned char hi[SL_AES_KEY_LEN];
|
||
unsigned char good[SL_AES_KEY_LEN];
|
||
unsigned char bad[SL_AES_KEY_LEN];
|
||
unsigned char aes[SL_AES_KEY_LEN];
|
||
ionu_derive_key (shortword, hi);
|
||
ionu_derive_key (goodword, good);
|
||
ionu_derive_key (badword, bad);
|
||
Key qKey ("Good", "", SL_AES_KEY_LEN, good, Key::AES);
|
||
|
||
// Test JSON and SQLite based keyrings for interop
|
||
Keyring qtest ("SQLite", "test/qtest.iks", qKey);
|
||
qtest.AddKey ("CloudGuard", "CG half key", SL_AES_KEY_LEN, good, Key::AES);
|
||
qtest.AddKey ("String", "", 6, (unsigned char*)"string", Key::STRING);
|
||
Keyring utest ("JSON", "");
|
||
cout << qtest.Stringify (qKey) << endl;
|
||
utest.LoadFromJSON (qtest.Stringify (qKey));
|
||
cout << utest.Stringify (qKey) << endl;
|
||
utest.Unlock (good);
|
||
const Key* uk = utest.GetKey ("CloudGuard");
|
||
const Key* qk = qtest.GetKey ("CloudGuard");
|
||
if (!uk->Equals (*qk))
|
||
rc += testfailed ("SQLite and JSON key mismatch", "CloudGuard");
|
||
else
|
||
printf ("JSON and SQLite based keyrings interop passed\n");
|
||
uk->Dump();
|
||
qk->Dump();
|
||
|
||
|
||
// Test public key encrypt/decrypt
|
||
k = new Key ("test", "Import/Export", "test/private_key.pem", "");
|
||
pbuff = k->PublicKeyEncrypt ((unsigned char*)"Howdy", 6, &bytes);
|
||
printf ("PK howdy %d bytes\n", (int)bytes);
|
||
if (pbuff) {
|
||
printf ("Howdy 6 bytes in, %d bytes out\n", (int)bytes);
|
||
back = k->PrivateKeyDecrypt (pbuff, bytes, &bytes);
|
||
if (strcmp ((char*)back, "Howdy") != 0)
|
||
rc += testfailed ("pkey decrypt", (char*)back);
|
||
else
|
||
printf ("Howdy, decrypted %d bytes\n", (int)bytes);
|
||
delete[] back;
|
||
delete[] pbuff;
|
||
}
|
||
else
|
||
rc += testfailed ("pkey encrypt", "Howdy");
|
||
delete k;
|
||
|
||
k = new Key ("test", "Import/Export", "test/private_key.der", "");
|
||
k->Export ("t.pem", "");
|
||
if (! filecompare ("t.pem", "test/private_key.pem"))
|
||
rc += testfailed ("Export (from der)", "t.pem");
|
||
delete k;
|
||
// TODO, get import of encrypted keys working
|
||
//k = new Key ("test", "Import/Export", "test/pk8_des.pem", "pk8_des");
|
||
//delete k;
|
||
//k = new Key ("test", "Import/Export", "test/pk8_3des.pem", "pk8_3des");
|
||
//delete k;
|
||
|
||
// Create a keyring, add 3 keys and lock with short password
|
||
Keyring* ring = new Keyring ("testring", "Test Key Ring");
|
||
Key* key1 = new Key ("Sample", "do not duplicate", 16, (const unsigned char*) "0123456789abcdef", Key::GENERIC);
|
||
key1->Dump();
|
||
Key* key2 = new Key ("Example", "do duplicate", 16, (const unsigned char*) "fedcba9876543210", Key::STRING);
|
||
//key2->Dump();
|
||
//Key* key3 = new Key ("6a0ce1ec504b", "TGI good", SL_AES_KEY_LEN, good, Key::TGI);
|
||
//Key* key4 = new Key ("ea7cb39afc1a", "TGI bad", SL_AES_KEY_LEN, bad, Key::TGI);
|
||
//key3->Dump();
|
||
if (! ring->AddKey (key1))
|
||
rc += testfailed ("Keyring::AddKey", key1->GetName());
|
||
if (! ring->AddKey (key2))
|
||
rc += testfailed ("Keyring::AddKey", key2->GetName());
|
||
//if (! ring->AddKey (key3))
|
||
// rc += testfailed ("Keyring::AddKey", key3->GetName());
|
||
ring->Dump();
|
||
//ring->AddKey (key4);
|
||
//ring->Dump();
|
||
//key3 = new Key ("6a0ce1ec504b", "SL good", SL_AES_KEY_LEN, good, Key::TGI);
|
||
//ring->AddKey (key3);
|
||
//key3 = new Key ("6a0ce1ec504b", "SL good", SL_AES_KEY_LEN, good, Key::TGI);
|
||
if (ring->Lock (shortword))
|
||
printf ("Lock succeeded\n");
|
||
else
|
||
rc += testfailed ("Keyring::Lock", shortword);
|
||
|
||
// Unlock with short password and verify keys
|
||
if (ring->Unlock (shortword))
|
||
printf ("Unlock succeeded\n");
|
||
else
|
||
rc += testfailed ("Keyring::Unlock", shortword);
|
||
if (! ring->GetKey (key1->GetName()))
|
||
rc += testfailed ("Keyring::GetKey", key1->GetName());
|
||
if (! ring->GetKey (key2->GetName()))
|
||
rc += testfailed ("Keyring::GetKey", key2->GetName());
|
||
//if (! ring->GetKey (key3->GetName()))
|
||
// rc += testfailed ("Keyring::GetKey", key3->GetName());
|
||
k = new Key ("Example", "updated", 16, (const unsigned char*) "0123fedcba987654", Key::STRING);
|
||
if (! ring->UpdateKey (k))
|
||
rc += testfailed ("Keyring::UpdateKey", key2->GetName());
|
||
delete k;
|
||
const Key* ck = ring->GetKey (key2->GetName());
|
||
ck->Dump();
|
||
|
||
|
||
// Lock with new password
|
||
ring->Lock (goodword);
|
||
//ck = ring->GetKey (key3->GetName());
|
||
//ck->Dump();
|
||
ring->Unlock (goodword);
|
||
ck = ring->GetKey (key2->GetName());
|
||
if (strncmp ((char*)ck->GetKey(), "0123fedcba987654", 16) != 0)
|
||
rc += testfailed ("Keyring::GetKey decrypted", k->GetName());
|
||
else
|
||
printf ("Key decrypt succeeded\n");
|
||
ring->Dump();
|
||
/*
|
||
if (!ring->RenewTGICache(43200)) // Set expiration to 1/2 day
|
||
rc += testfailed ("Keyring::RenewTGICache", ring->GetName());
|
||
ring->Dump();
|
||
if (!ring->ClearTGICache())
|
||
rc += testfailed ("Keyring::ClearTGICache", ring->GetName());
|
||
if (ring->GetNumKeys() != 2)
|
||
rc += testfailed ("Keyring::ClearTGICache", ring->GetName());
|
||
if (!ring->RenewTGICache(-2*86400)) // Subtract 2 days from the expiration
|
||
rc += testfailed ("Keyring::RenewTGICache", ring->GetName());
|
||
if (!ring->ClearTGICache())
|
||
rc += testfailed ("Keyring::ClearTGICache", ring->GetName());
|
||
delete key3;
|
||
key3 = new Key ("6a0ce1ec504b", "TGI sig/key pair", SL_AES_KEY_LEN, good, Key::TGI);
|
||
ring->AddKey (key3); // Add the TGI key back
|
||
if (!ring->RenewTGICache(-2*86400)) // Set expiration to 2 days ago
|
||
rc += testfailed ("Keyring::RenewTGICache", ring->GetName());
|
||
ring->Lock (goodword);
|
||
ring->SaveAs (keystore);
|
||
delete ring;
|
||
ring = new Keyring (keystore);
|
||
if (!ring->Unlock (goodword))
|
||
rc += testfailed ("Keyring::Unlock after TGI", ring->GetName());
|
||
//ring->Dump();
|
||
if (ring->GetKey("TGIsignature"))
|
||
rc += testfailed ("Keyring::ClearTGICache (not expired)", ring->GetName());
|
||
else
|
||
printf ("TGI key expiration test succeeded\n");
|
||
*/
|
||
// Import from X.509, generate pin hash
|
||
if (!ring->ImportPubKeyFromCert ("test/ionu.pem"))
|
||
rc += testfailed ("Keyring::ImportPubKeyFromCert", "test_cert.pem");
|
||
else {
|
||
const Key* pub = ring->GetKey ("cert");
|
||
if (pub) {
|
||
pub->Export ("cert_pk.der", "");
|
||
std::string pin = sequencelogic::DigestFile ("sha1", "cert_pk.der");
|
||
cout << "X.509 pin hash: " << pin << endl;
|
||
}
|
||
else {
|
||
rc += testfailed ("Keyring::ImportPubKeyFromCert get pubkey", "cert");
|
||
Key junk;
|
||
cout << ring->Stringify (junk);
|
||
}
|
||
}
|
||
|
||
// Generate RSA key pair
|
||
if (ring->GenerateRSAKey("CloudGuard", "RSA keypair"))
|
||
printf ("Generated RSA keypair\n");
|
||
else
|
||
rc += testfailed ("GeneratedRSAKey", "CloudGuard");
|
||
const Key* privateK = ring->GetKey("CloudGuard");
|
||
|
||
// Test RSA IES hybrid encryption
|
||
pbuff = privateK->RSAIESEncrypt ((unsigned char*)megaMeta, strlen(megaMeta)+1, &bytes);
|
||
back = privateK->RSAIESDecrypt (pbuff, bytes, &bytes);
|
||
if (sequencelogic::StrCmp ((char*)back, megaMeta) != 0)
|
||
rc += testfailed ("RSAIESEncrypt()", "CloudGuard");
|
||
if (pbuff) delete[] pbuff;
|
||
if (back) delete[] back;
|
||
|
||
char* pk = ring->GetPubKey("CloudGuard");
|
||
if (!pk)
|
||
rc += testfailed ("Keyring::GetPubKey", "CloudGuard not found");
|
||
else if (strncmp (pk, "-----BEGIN PUBLIC KEY", 21) != 0)
|
||
rc += testfailed ("Keyring::GetPubKey", "CloudGuard");
|
||
Key* publicK = NULL;
|
||
if (pk) {
|
||
publicK = new Key ("CgPublic", "CloudGuard public key", (int)strlen(pk), (const unsigned char*) pk, Key::RSA_PUBLIC);
|
||
delete[] pk;
|
||
// Test public key encrypt/decrypt
|
||
pbuff = publicK->PublicKeyEncrypt ((unsigned char*)"Howdy", 6, &bytes);
|
||
if (pbuff) {
|
||
back = privateK->PrivateKeyDecrypt (pbuff, bytes, &bytes);
|
||
if (back == nullptr || strcmp ((char*)back, "Howdy") != 0)
|
||
rc += testfailed ("pkey decrypt", (char*)back);
|
||
if (back) delete[] back;
|
||
|
||
// Try decrypt with wrong private key
|
||
Key* badBOT = new Key ("BadBot", "RSA key", (int)strlen(BOT_private), (const unsigned char*)BOT_private, Key::RSA);
|
||
back = badBOT->PrivateKeyDecrypt (pbuff, 256, &bytes);
|
||
if (back || bytes > 0)
|
||
rc += testfailed ("badBOT decrypt", (char*)back);
|
||
else
|
||
printf ("RSA decrypt test with wrong key succeeded\n");
|
||
delete[] pbuff;
|
||
}
|
||
else
|
||
rc += testfailed ("pkey encrypt", "Howdy");
|
||
|
||
pbuff = privateK->PrivateKeySign ((unsigned char*)"ydwoH", 6, &bytes);
|
||
if (pbuff) {
|
||
// Verify match and not matched
|
||
if (publicK->PublicKeyVerify (pbuff, bytes, (unsigned char*)"ydwoH", 6) != 1)
|
||
rc += testfailed ("pkey verify", "ydwoH");
|
||
else
|
||
printf ("Sign and very tests passed\n");
|
||
if (publicK->PublicKeyVerify (pbuff, bytes, (unsigned char*)"Howdy", 6) == 1)
|
||
rc += testfailed ("pkey verify bad", "Howdy");
|
||
delete[] pbuff;
|
||
}
|
||
else
|
||
rc += testfailed ("pkey sign:", "ydwoH");
|
||
}
|
||
|
||
// Test secret + challenge key generation
|
||
Keyring sss ("Secret", "test");
|
||
Key k1, k2, k3, k4;
|
||
std::string sname = "RSA - secret";
|
||
std::string sdesc = "test";
|
||
std::string schal = "";
|
||
std::string ssalt = "";
|
||
std::string sempty = "";
|
||
std::string ssret ("secret78$joe@gmail.com$urn:sl:001001:::");
|
||
std::string van ("urn:sl:001001:::");
|
||
#ifdef LIN64
|
||
std::vector<std::string> elist ({ "joe@sequencelogic.net", "jenny@sequencelogic.net", "jones@sequencelogic.net" });
|
||
|
||
if (!sss.GenerateRSAKeys (van, elist))
|
||
rc += testfailed ("Corporate email based pre-provisioning", "bulk");
|
||
#endif
|
||
|
||
// Verify old style unsalted challenges
|
||
sss.GenerateRSAKey ("RSA-old", "", "[sequencelogic::challenges]");
|
||
sss.GenerateRSAKey ("RSA-new", sempty, "[sequencelogic::challenges]", sempty, sempty);
|
||
sss.GetKey ("RSA-old", k1);
|
||
sss.GetKey ("RSA-new", k2);
|
||
if (k1.Equals (k2))
|
||
printf ("Unsalted key generation tests passed\n");
|
||
else
|
||
rc += testfailed ("Unsalted challenge key generation tests", "RSA - old != new");
|
||
|
||
// Verify random salted challenges
|
||
unsigned char rsalt[SL_SHA256_LEN];
|
||
char b64[SL_SHA256_LEN * 4];
|
||
sequencelogic::RandomBytes (SL_SHA256_LEN, rsalt);
|
||
sequencelogic::Base64Encode (rsalt, SL_SHA256_LEN, b64);
|
||
std::string bsalt = b64;
|
||
sss.GenerateRSAKey ("RSA-salted1", sempty, "[sequencelogic::challenges]", sempty, bsalt);
|
||
sequencelogic::BinaryToHex (rsalt, SL_SHA256_LEN, b64);
|
||
std::string hsalt = b64;
|
||
sss.GenerateRSAKey ("RSA-salted1h", sempty, "[sequencelogic::challenges]", sempty, hsalt);
|
||
sequencelogic::RandomBytes (SL_SHA256_LEN, rsalt);
|
||
sequencelogic::Base64Encode (rsalt, SL_SHA256_LEN, b64);
|
||
bsalt = b64;
|
||
sss.GenerateRSAKey ("RSA-salted2", sempty, "[sequencelogic::challenges]", sempty, bsalt);
|
||
bsalt = "random";
|
||
sss.GenerateRSAKey ("RSA-salter", sempty, "[sequencelogic::challenges]", sempty, bsalt);
|
||
sss.GetKey ("RSA-salted1", k1);
|
||
sss.GetKey ("RSA-salted1h", k2);
|
||
sss.GetKey ("RSA-salted2", k3);
|
||
sss.GetKey ("RSA-salter", k4);
|
||
if (k1.Equals (k3) && !(k1.Equals (k2)) && !(k1.Equals (k4)))
|
||
rc += testfailed ("Salted challenge key generation tests", "RSA - salted 1 = 2");
|
||
else
|
||
printf ("Random salted key generation tests passed\n");
|
||
|
||
// Verify secret based keys
|
||
sss.GenerateRSAKey (sname, sdesc, schal, ssret, ssalt);
|
||
sss.GetKey (sname, k1);
|
||
schal = "[sequencelogic::challenges]";
|
||
sname = "RSA - secret + challenge";
|
||
// Create key with secret, and return "salt"
|
||
sss.GenerateRSAKey (sname, sdesc, schal, ssret, ssalt);
|
||
sss.GetKey (sname, k2);
|
||
ssret = "";
|
||
// Create key with challenges and "salt"
|
||
sname = "RSA - secret + salt";
|
||
sss.GenerateRSAKey (sname, sdesc, schal, ssret, ssalt);
|
||
sss.GetKey (sname, k3);
|
||
if (k1.Equals (k2) && k1.Equals (k3))
|
||
printf ("Secret challenge key generation tests passed\n");
|
||
else {
|
||
k1.Dump();
|
||
k2.Dump();
|
||
k3.Dump();
|
||
rc += testfailed ("Secret challenge key generation tests", "RSA - secret");
|
||
}
|
||
|
||
// Test EC key generation and ECDH generation of shared secret between peers
|
||
ring->GenerateECKey("me", "mine");
|
||
ring->GenerateECKey("peer", "theirs");
|
||
ring->GenerateECKey("third", "theirs");
|
||
pk = ring->GetPubKey ("me");
|
||
Key* mypubkey = new Key ("EcPublic", "Electric CloudGuard public key", (int)strlen(pk), (const unsigned char*) pk, Key::EC_PUBLIC);
|
||
delete[] pk;
|
||
pk = ring->GetPubKey ("peer");
|
||
Key* peerpubkey = new Key ("EcPublic", "Electric CloudGuard public key", (int)strlen(pk), (const unsigned char*) pk, Key::EC_PUBLIC);
|
||
peerpubkey->Export ("test/ec_pub.pem", "");
|
||
delete[] pk;
|
||
ring->GenerateECKey ("MyChallenge", "deterministic", challenges);
|
||
ring->GenerateECKey ("PeerChallenge", "deterministic", challenges1);
|
||
const Key* me = ring->GetKey ("me");
|
||
me->Export ("test/ec_priv.pem", "");
|
||
const Key* peer = ring->GetKey ("peer");
|
||
const Key* third = ring->GetKey ("third");
|
||
const Key* mychallenge = ring->GetKey ("MyChallenge");
|
||
mychallenge->Export ("test/ec_challenge.pem", "");
|
||
const Key* peerchallenge = ring->GetKey ("PeerChallenge");
|
||
unsigned char* secret = NULL;
|
||
size_t secret_len;
|
||
char ascii[256];
|
||
secret = me->GenerateECDHSecret (peer, &secret_len);
|
||
sequencelogic::Base64Encode (secret, secret_len, ascii);
|
||
printf ("ECDH m+p: %s\n", ascii);
|
||
delete[] secret;
|
||
secret = me->GenerateECDHSecret (peerpubkey, &secret_len);
|
||
sequencelogic::Base64Encode (secret, secret_len, ascii);
|
||
printf ("ECDH m+p: %s\n", ascii);
|
||
delete[] secret;
|
||
secret = peer->GenerateECDHSecret (me, &secret_len);
|
||
sequencelogic::Base64Encode (secret, secret_len, ascii);
|
||
printf ("ECDH p+m: %s\n", ascii);
|
||
delete[] secret;
|
||
secret = me->GenerateECDHSecret (third, &secret_len);
|
||
sequencelogic::Base64Encode (secret, secret_len, ascii);
|
||
printf ("ECDH m+t: %s\n", ascii);
|
||
delete[] secret;
|
||
secret = third->GenerateECDHSecret (me, &secret_len);
|
||
sequencelogic::Base64Encode (secret, secret_len, ascii);
|
||
printf ("ECDH t+m: %s\n", ascii);
|
||
delete[] secret;
|
||
secret = peer->GenerateECDHSecret (third, &secret_len);
|
||
sequencelogic::Base64Encode (secret, secret_len, ascii);
|
||
printf ("ECDH p+t: %s\n", ascii);
|
||
delete[] secret;
|
||
secret = third->GenerateECDHSecret (peer, &secret_len);
|
||
sequencelogic::Base64Encode (secret, secret_len, ascii);
|
||
printf ("ECDH t+p: %s\n", ascii);
|
||
delete[] secret;
|
||
secret = mychallenge->GenerateECDHSecret (peerchallenge, &secret_len);
|
||
sequencelogic::Base64Encode (secret, secret_len, ascii);
|
||
printf ("ECDH challenge m+p: %s\n", ascii);
|
||
delete[] secret;
|
||
secret = peerchallenge->GenerateECDHSecret (mychallenge, &secret_len);
|
||
sequencelogic::Base64Encode (secret, secret_len, ascii);
|
||
printf ("ECDH challenge p+m: %s\n", ascii);
|
||
delete[] secret;
|
||
|
||
// Test EC public key encrypt/decrypt
|
||
pbuff = me->ECDHEncrypt (peerpubkey, (unsigned char*)"Howdy we are having some funny now", 35, &bytes);
|
||
//printf ("EC: PK howdy %d bytes\n", (int)bytes);
|
||
if (pbuff) {
|
||
printf ("EC: Howdy 35 bytes in, %d bytes out\n", (int)bytes);
|
||
back = peer->ECDHDecrypt (mypubkey, pbuff, bytes, &bytes);
|
||
if (strcmp ((char*)back, "Howdy we are having some funny now") != 0)
|
||
rc += testfailed ("pkey decrypt", (char*)back);
|
||
else
|
||
printf ("EC: %s, decrypted %d bytes\n", (char*)back, (int)bytes);
|
||
delete[] back;
|
||
delete[] pbuff;
|
||
}
|
||
else
|
||
rc += testfailed ("EC: pkey encrypt", "Howdy");
|
||
|
||
pbuff = me->ECDHEncrypt (peerpubkey, (unsigned char*)"Howdy we are having some funny now", 35, &bytes);
|
||
if (pbuff) {
|
||
pbuff[bytes - 2] = 85;
|
||
back = peer->ECDHDecrypt (mypubkey, pbuff, bytes, &bytes);
|
||
if (back)
|
||
rc += testfailed ("EC: authentication", "HMAC");
|
||
else
|
||
printf ("EC: Authentication fail test passed\n");
|
||
delete[] pbuff;
|
||
}
|
||
pbuff = me->ECDHEncrypt (peerpubkey, hi, SL_AES_KEY_LEN, &bytes);
|
||
if (pbuff) {
|
||
printf ("EC: AES 32 bytes in, %d bytes out\n", (int)bytes);
|
||
back = peer->ECDHDecrypt (mypubkey, pbuff, bytes, &bytes);
|
||
if (sequencelogic::MemCmp (back, hi, SL_AES_KEY_LEN) != 0)
|
||
rc += testfailed ("pkey aes decrypt", (char*)back);
|
||
else
|
||
printf ("ECDH encrypt/decrypt of AES key passed\n");
|
||
delete[] pbuff;
|
||
delete[] back;
|
||
}
|
||
else
|
||
rc += testfailed ("pkey encrypt", "Howdy");
|
||
|
||
pbuff = mypubkey->ECIESEncrypt ((unsigned char*)"Howdy we are having some ecies now", 35, &bytes);
|
||
back = me->ECIESDecrypt (pbuff, bytes, &bytes);
|
||
if (!back || strcmp ((char*)back, "Howdy we are having some ecies now") != 0)
|
||
rc += testfailed ("ECIES encryption failed", (char*)back);
|
||
else
|
||
printf ("ECIES me encrypt/decrypt passed - %s\n", (char*)back);
|
||
delete[] pbuff;
|
||
delete[] back;
|
||
pbuff = peerpubkey->ECIESEncrypt ((unsigned char*)"Howdy we are having some ecies fun", 35, &bytes);
|
||
back = peer->ECIESDecrypt (pbuff, bytes, &bytes);
|
||
if (!back || strcmp ((char*)back, "Howdy we are having some ecies fun") != 0)
|
||
rc += testfailed ("ECIES encryption failed", (char*)back);
|
||
else
|
||
printf ("ECIES peer encrypt/decrypt passed - %s\n", (char*)back);
|
||
delete[] pbuff;
|
||
delete[] back;
|
||
delete peerpubkey;
|
||
delete mypubkey;
|
||
|
||
// Test AES key generation, symmetric en/decrypt and public key encrypt/decrypt of that key
|
||
ring->GenerateAESKey("CloudGuardTGI", "TGI half key");
|
||
const Key* aesKey = ring->GetKey ("CloudGuardTGI");
|
||
unsigned char iv[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 'a', 'b', 'c', 'd', 'e', 'f'};
|
||
size_t ebytes = 0;
|
||
unsigned char* ct = aesKey->SymmetricEncryptBuffer ((unsigned char*)PERMS, strlen (PERMS), &ebytes, iv);
|
||
unsigned char* pt = aesKey->SymmetricDecryptBuffer (ct, ebytes, &ebytes, iv);
|
||
if (sequencelogic::MemCmp (pt, PERMS, strlen (PERMS)) != 0)
|
||
rc += testfailed ("Key::SymmetricEncryptBuffer", "perms");
|
||
delete[] ct;
|
||
delete[] pt;
|
||
aesKey->SymmetricEncryptFile (testfile, "test/tartest.enc", iv);
|
||
aesKey->SymmetricDecryptFile ("test/tartest.enc", "test/tartest.dec", iv);
|
||
if (filecompare (testfile, "test/tartest.dec"))
|
||
printf ("SymmetricEncryptFile tartest.txt\n");
|
||
else
|
||
rc += testfailed ("Key::SymmetricEncryptFile", testfile);
|
||
|
||
// Test 128 bit key
|
||
unsigned char b128[16];
|
||
sequencelogic::RandomBytes (16, b128);
|
||
Key aes128 ("AES 128", "CBC", 16, b128, Key::AES);
|
||
ct = aes128.SymmetricEncryptBuffer ((unsigned char*)PERMS, strlen (PERMS), &ebytes, iv);
|
||
pt = aes128.SymmetricDecryptBuffer (ct, ebytes, &ebytes, iv);
|
||
if (sequencelogic::MemCmp (pt, PERMS, ebytes) != 0)
|
||
rc += testfailed ("Key::SymmetricEncryptBuffer aes128cbc", "perms");
|
||
delete[] ct;
|
||
delete[] pt;
|
||
|
||
// Test Authenticated GCM with and without additional authenticated data
|
||
unsigned char aad[] = {'a', 'a', 'd', 'd'};
|
||
unsigned char abd[] = {'a', 'b', 'd', 'd'};
|
||
|
||
// No aad
|
||
ct = aesKey->SymmetricEncryptAuthenticated ((unsigned char*)PERMS, strlen (PERMS), &ebytes, iv);
|
||
pt = aesKey->SymmetricDecryptAuthenticated (ct, ebytes, &ebytes, iv);
|
||
if (sequencelogic::MemCmp (pt, PERMS, ebytes) != 0)
|
||
rc += testfailed ("Key::SymmetricEncryptAuthenticated", "");
|
||
delete[] ct;
|
||
delete[] pt;
|
||
|
||
// With aad
|
||
ct = aesKey->SymmetricEncryptAuthenticated ((unsigned char*)PERMS, strlen (PERMS), &ebytes, iv, aad, 4);
|
||
pt = aesKey->SymmetricDecryptAuthenticated (ct, ebytes, &ebytes, iv, aad, 4);
|
||
if (sequencelogic::MemCmp (pt, PERMS, ebytes) != 0)
|
||
rc += testfailed ("Key::SymmetricEncryptAuthenticated", "+ aad");
|
||
delete[] pt;
|
||
|
||
// With invalid aad
|
||
pt = aesKey->SymmetricDecryptAuthenticated (ct, ebytes, &ebytes, iv, abd, 4);
|
||
if (pt)
|
||
rc += testfailed ("Key::SymmetricEncryptAuthenticated", "bad aad");
|
||
delete[] ct;
|
||
|
||
memcpy (aes, ring->GetKey ("CloudGuardTGI")->GetKey(), SL_AES_KEY_LEN);
|
||
pbuff = publicK->PublicKeyEncrypt (aes, SL_AES_KEY_LEN, &bytes);
|
||
if (pbuff) {
|
||
back = privateK->PrivateKeyDecrypt (pbuff, bytes, &bytes);
|
||
if (sequencelogic::MemCmp (back, aes, SL_AES_KEY_LEN) != 0)
|
||
rc += testfailed ("pkey aes decrypt", (char*)back);
|
||
else
|
||
printf ("TGI half key tests passed\n");
|
||
delete[] pbuff;
|
||
delete[] back;
|
||
}
|
||
else
|
||
rc += testfailed ("pkey encrypt", "Howdy");
|
||
delete publicK;
|
||
|
||
//ring->GenerateRSAKey ("Holy", "moly", challenges);
|
||
ring->Dump();
|
||
ring->Lock (goodword);
|
||
ring->Unlock (goodword);
|
||
ring->Lock (goodword);
|
||
|
||
unsigned char salt[SL_AES_KEY_LEN];
|
||
sequencelogic::GenerateCGKey ("u3K2*l$qZ0a<", aes, salt);
|
||
if (sequencelogic::ValidateCGKey ("u3K2*l$qZ0a<", aes, salt))
|
||
printf ("CG key generate/validate passed\n");
|
||
if (sequencelogic::ValidateCGKey ("not good", aes, salt))
|
||
rc += testfailed ("CG validate", "not good");
|
||
memset (salt, 85, SL_AES_KEY_LEN);
|
||
if (sequencelogic::ValidateCGKey ("u3K2*l$qZ0a<", aes, salt))
|
||
rc += testfailed ("CG validate", "who passed the pepper?");
|
||
|
||
// Failure tests, bad password
|
||
if (ring->Unlock (badword))
|
||
rc += testfailed ("Keyring::Unlock", badword);
|
||
if (!ring->Unlock (goodword))
|
||
rc += testfailed ("Keyring::Unlock", "after bad");
|
||
|
||
delete ring;
|
||
|
||
// Create a keyring, add 10000 keys, lock, save, delete, load and find the 4777th key
|
||
ring = new Keyring ("testring", "Test Key Ring");
|
||
char keyname[32];
|
||
for (int i = 0; i < 10000; ++i) {
|
||
sprintf (keyname, "key%d", i);
|
||
Key* key = new Key (keyname, "one of many", 16, (const unsigned char*) "0123456789abcdef", Key::GENERIC);
|
||
if (! ring->AddKey (key))
|
||
rc += testfailed ("Keyring::AddKey", keyname);
|
||
}
|
||
ring->Lock (goodword);
|
||
ring->SaveAs ("test/thousand.iks");
|
||
delete ring;
|
||
ms = sequencelogic::GetSystemTime();
|
||
ring = new Keyring ("test/thousand.iks");
|
||
ring->Unlock (goodword);
|
||
if (! ring->GetKey ("key4777"))
|
||
rc += testfailed ("Keyring::GetKey", "key4777");
|
||
else {
|
||
ms = sequencelogic::GetSystemTime() - ms;
|
||
printf ("Loaded 10,000 keys, unlocked and found key4777 in %ld ms\n", ms);
|
||
}
|
||
if (! ring->RemoveKey ("key4777"))
|
||
rc += testfailed ("Keyring::RemoveKey", "key4777");
|
||
if (ring->GetNumKeys() != 9999)
|
||
rc += testfailed ("Keyring::RemoveKey", "9999");
|
||
delete ring;
|
||
|
||
// Test linked key rings
|
||
ring = new Keyring ("testring", "Test Linked Key Rings");
|
||
key1 = new Key ("Test", "key", 16, (const unsigned char*) "fedcba9876543210", Key::STRING);
|
||
key2 = new Key ("Example", "do duplicate", 16, (const unsigned char*) "fedcba9876543210", Key::STRING);
|
||
ring->AddKey (key1);
|
||
ring->Lock (goodword);
|
||
ring->SaveAs ("test/linked.iks");
|
||
delete ring;
|
||
ring = new Keyring ("test/linked.iks");
|
||
ring->Unlock (good);
|
||
Keyring* link1 = new Keyring ("private ring", "Private Key Ring");
|
||
Keyring* link2 = new Keyring ("public ring", "Public Key Ring");
|
||
link2->AddKey (key2);
|
||
ring->AddKeyring (link1);
|
||
ring->AddKeyring (link2);
|
||
ring->Lock (goodword);
|
||
ring->SaveAs ("test/linked.iks");
|
||
delete ring;
|
||
ring = new Keyring ("test/linked.iks");
|
||
ring->Unlock (goodword);
|
||
const Keyring* t = ring->GetKeyring ("public ring");
|
||
if (!t)
|
||
rc += testfailed ("GetKeyring", "public ring");
|
||
if (t && !t->GetKey ("Example"))
|
||
rc += testfailed ("GetKeyring()->GetKey()", "Example");
|
||
if (!ring->RemoveKeyring ("public ring"))
|
||
rc += testfailed ("RemoveKeyring", "public ring");
|
||
delete ring;
|
||
|
||
int rrc = rc;
|
||
k = new Key ("test", "Import/Export", "test/private_key.pem", "");
|
||
k->Export ("t.pem", "");
|
||
if (! filecompare ("t.pem", "test/private_key.pem"))
|
||
rc += testfailed ("Export", "t.pem");
|
||
k->Export ("t.der", "");
|
||
if (! filecompare ("t.der", "test/private_key.der"))
|
||
rc += testfailed ("Export", "t.der");
|
||
if (!k->Import ("test/ec_challenge.pem" , "") || k->GetType() != Key::EC)
|
||
rc += testfailed ("Import", "test/ec_challenge.pem");
|
||
if (!k->Import ("test/ec_pub.pem" , "") || k->GetType() != Key::EC_PUBLIC)
|
||
rc += testfailed ("Import", "test/ec_pub.pem");
|
||
if (!k->Import ("test/private_key.pem" , "") || k->GetType() != Key::RSA)
|
||
rc += testfailed ("Import", "test/private_key.pem");
|
||
if (!k->Import ("test/public_key.pem" , "") || k->GetType() != Key::RSA_PUBLIC)
|
||
rc += testfailed ("Import", "test/public_key.pem");
|
||
if (k->Import ("test/test_cert.pem" , "") || k->GetType() != Key::GENERIC)
|
||
rc += testfailed ("Import", "test/test_cert.pem");
|
||
|
||
// Verify PEM and JSON loaded keys match
|
||
Key BOT ("Bot", "RSA key", BOT_public, Key::RSA_PUBLIC);
|
||
Key JBOT ("jsonBot", "RSA key", BOT_jsonkey, Key::RSA_PUBLIC);
|
||
EyeJSONObject botJSON (BOT_json);
|
||
EyeJSONScalar* botpk = (EyeJSONScalar*)botJSON.GetMember ("publicKey");
|
||
if (sequencelogic::StrCmp ((char*)BOT.GetKey(), botpk->GetValue()) != 0)
|
||
rc += testfailed ("{publicKey:", "BOT_json}");
|
||
if (!BOT.Equals (JBOT))
|
||
rc += testfailed ("JSON String", "BOT_jsonkey");
|
||
|
||
if (rc == rrc)
|
||
printf ("Import/Export tests passed\n");
|
||
delete k;
|
||
|
||
|
||
printf ("Bad keyring tests\n");
|
||
ring = new Keyring ((char*)good);
|
||
delete ring;
|
||
ring = new Keyring ("test/test.ionu");
|
||
delete ring;
|
||
ring = new Keyring ("test/badmagic.iks");
|
||
ring->Unlock (good);
|
||
if (ring->GetKey ("Test"))
|
||
rc += testfailed ("GetKey", "bad magic");
|
||
delete ring;
|
||
ring = new Keyring ("test/badiv.iks");
|
||
if (ring->Unlock (good))
|
||
rc += testfailed ("GetKey", "bad iv");
|
||
delete ring;
|
||
ring = new Keyring ("test/badigest.iks");
|
||
if (ring->Unlock (good))
|
||
rc += testfailed ("GetKey", "bad digest");
|
||
delete ring;
|
||
ring = new Keyring ("test/munged.iks");
|
||
ring->Unlock (good);
|
||
if (ring->GetKey ("Test"))
|
||
rc += testfailed ("GetKey", "munged");
|
||
delete ring;
|
||
|
||
// Test SQLite based keyring
|
||
std::string sqlkeyname = "SQLtest";
|
||
Key mkey ("Meta", "ring key", SL_AES_KEY_LEN, good, Key::AES);
|
||
Keyring sqlring ("SQLite", "keys.db", mkey);
|
||
sqlring.AddKey ("SQLtest", "AES key", SL_AES_KEY_LEN, bad, Key::AES);
|
||
sqlring.AddKey ("test", "AES key", SL_AES_KEY_LEN, good, Key::AES);
|
||
cout << sqlring.GetKeyNames() << endl;;
|
||
cout << sqlring.Stringify (mkey) << endl;;
|
||
Key tkey;
|
||
sqlring.GetKey (sqlkeyname, tkey);
|
||
if (memcmp (tkey.GetKey(), bad, SL_AES_KEY_LEN) != 0)
|
||
rc += testfailed ("GetKey", "SQLite");
|
||
else
|
||
printf ("SQLite keyring test passed\n");
|
||
|
||
if (!sqlring.RemoveKey (sqlkeyname))
|
||
rc += testfailed ("RemoveKey", "test");
|
||
printf ("remove\n");
|
||
if (sqlring.GetKey (sqlkeyname, tkey))
|
||
rc += testfailed ("GetKey after RemoveKey", "test");
|
||
printf ("get\n");
|
||
sqlring.Dump();
|
||
printf ("dump\n");
|
||
if (rc == 0)
|
||
printf ("C++ Keyring tests passed\n-------------------------------\n");
|
||
|
||
unsigned char kk[4096];
|
||
const char* PEM = "-----BEGIN RSA PRIVATE KEY-----";
|
||
char prv[2048];
|
||
char pub[2048];
|
||
ionu_eyering_gen_rsa_pair (prv, pub);
|
||
//ionu_eyering_shred ("test/test.iks");
|
||
if (!ionu_eyering_create ("test/test.iks", "KeyRIng", "Local key ring", hi))
|
||
rc += testfailed ("ionu_eyering_create", "KeyRIng");
|
||
else
|
||
printf ("ionu_eyering_create() KeyRIng passed\n");
|
||
if (ionu_eyering_get_key ("test/test.iks", "CloudGuard", kk, hi))
|
||
rc += testfailed ("ionu_eyering_get_key", "no keys");
|
||
|
||
sequencelogic::RandomBytes (32, kk);
|
||
ionu_eyering_add_binkey ("test/test.iks", "AES", "Random AES key", SL_AES_KEY_LEN, kk, hi);
|
||
ionu_eyering_add_strkey ("test/test.iks", "Sample", "do not duplicate", "0123456789abcdef", hi);
|
||
//ionu_eyering_add_tgikey ("test/test.iks", "6a0ce1ec504b", "Cached TGI key", TGIkey, hi);
|
||
ionu_eyering_add_rsakey ("test/test.iks", "private", "Alan's private key", RSA_private, hi);
|
||
ionu_eyering_add_strkey ("test/test.iks", "perms", "Just JSON", PERMS, hi);
|
||
ionu_eyering_gen_rsa ("test/test.iks", "StorageGuard", "RSA keypair", hi);
|
||
ionu_eyering_gen_rsa ("test/test.iks", "Nikki", "RSA keypair", hi);
|
||
|
||
// Invite ch1, account ch2, provision ch3
|
||
ionu_eyering_gen_rsa_secret_challenge ("test/test.iks", "RSA-ch1", "pair", NULL, "secret78", NULL, hi);
|
||
char* sssalt = ionu_eyering_gen_rsa_secret_salt ("test/test.iks", "RSA-ch2", "pair", "[sequencelogic::json]", "secret78", hi);
|
||
ionu_eyering_gen_rsa_secret_challenge ("test/test.iks", "RSA-ch3", "pair", "[sequencelogic::json]", NULL, sssalt, hi);
|
||
char* ch1k = ionu_eyering_get_pubkey ("test/test.iks", "RSA-ch1", hi);
|
||
char* ch2k = ionu_eyering_get_pubkey ("test/test.iks", "RSA-ch2", hi);
|
||
char* ch3k = ionu_eyering_get_pubkey ("test/test.iks", "RSA-ch3", hi);
|
||
if (strcmp (ch1k, ch2k) == 0 && strcmp (ch1k, ch3k) == 0)
|
||
printf ("C secretly salted challenge key passed\n");
|
||
else
|
||
rc += testfailed ("ionu_eyering_gen_rsa_secret_challenge", "mismatched keys");
|
||
|
||
if (sssalt) free (sssalt);
|
||
if (ch1k) free (ch1k);
|
||
if (ch2k) free (ch2k);
|
||
if (ch3k) free (ch3k);
|
||
|
||
ionu_eyering_gen_rsa ("test/test.iks", "CloudGuard", "RSA keypair", hi);
|
||
ionu_eyering_gen_rsa ("test/test.iks", "CloudGuard", "RSA keypair", hi);
|
||
char* keynames = ionu_eyering_get_keynames ("test/test.iks");
|
||
printf ("Added: %s\n", keynames);
|
||
free (keynames);
|
||
char* strkey = ionu_eyering_get_strkey ("test/test.iks", "Sample", hi);
|
||
if (sequencelogic::StrCmp (strkey, "0123456789abcdef") != 0)
|
||
rc += testfailed ("ionu_eyering_get_strkey", "Sample");
|
||
if (strkey) free (strkey);
|
||
|
||
pk = ionu_eyering_get_pubkey ("test/test.iks", "CloudGuard", hi);
|
||
if (!pk || strncmp (pk, "-----BEGIN PUBLIC KEY", 21) != 0)
|
||
rc += testfailed ("ionu_eyering_get_pubkey", "CloudGuard");
|
||
free (pk);
|
||
ionu_eyering_get_key ("test/test.iks", "CloudGuard", kk, hi);
|
||
if (memcmp (kk, "-----BEGIN RSA PRIVATE KEY", 21) != 0)
|
||
rc += testfailed ("ionu_eyering_get_key", "CloudGuard");
|
||
strkey = ionu_eyering_get_strkey ("test/test.iks", "CloudGuard", hi);
|
||
if (memcmp (strkey, "-----BEGIN RSA PRIVATE KEY", 21) != 0)
|
||
rc += testfailed ("ionu_eyering_get_strkey", "CloudGuard");
|
||
if (strkey) free (strkey);
|
||
unsigned char rsabuff[256];
|
||
size_t rbytes = ionu_eyering_pubkey_encrypt ("test/test.iks", "CloudGuard", hi, bad, SL_AES_KEY_LEN, rsabuff);
|
||
rbytes = ionu_eyering_privatekey_decrypt ("test/test.iks", "CloudGuard", hi, rsabuff, rbytes, rsabuff);
|
||
if (rbytes != SL_AES_KEY_LEN || memcmp (bad, rsabuff, SL_AES_KEY_LEN) != 0)
|
||
rc += testfailed ("ionu_eyering_privatekey_decrypt", "Cloudgaurd");
|
||
else
|
||
printf ("ionu_eyering_pubkey_encrypt/privatekey_decrypt() passed\n");
|
||
size_t sbytes = ionu_eyering_privatekey_sign ("test/test.iks", "CloudGuard", hi, bad, SL_AES_KEY_LEN, rsabuff);
|
||
if (ionu_eyering_publickey_verify ("test/test.iks", "CloudGuard", hi, bad, SL_AES_KEY_LEN, rsabuff, sbytes))
|
||
printf ("ionu_eyering sign/verify() passed\n");
|
||
else
|
||
rc += testfailed ("ionu_eyering sign/verify() passed\n", "CloudGuard");
|
||
// Old libionu replacements (not secure and misnamed)
|
||
rbytes = ionu_eyering_rsaprivatekey_encrypt ("test/test.iks", "CloudGuard", hi, bad, SL_AES_KEY_LEN, rsabuff);
|
||
rbytes = ionu_eyering_rsapublickey_decrypt ("test/test.iks", "CloudGuard", hi, rsabuff, rbytes, rsabuff);
|
||
if (rbytes != SL_AES_KEY_LEN || memcmp (bad, rsabuff, SL_AES_KEY_LEN) != 0)
|
||
rc += testfailed ("ionu_eyering_rsapublickey_decrypt", "Cloudgaurd");
|
||
else
|
||
printf ("ionu_eyering_rsaprivatekey_encrypt/ionu_eyering_rsapublickey_decrypt() passed\n");
|
||
|
||
char public_pem[4096];
|
||
char private_pem[8192];
|
||
ionu_eyering_create ("test/rsa.iks", "KeyRIng", "RSA key ring", hi);
|
||
const char* ch = "-----BEGIN PUBLIC KEY-----\n\
|
||
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEApmPB9KDsrOI1J6jntYbN\n\
|
||
Oj9uWUewW+cluNQ0fVCGqoDZ5WLLrz3kpKPlGkI93TraNh2KyyTGDNN0QnCMaOM4\n\
|
||
biPfl+z/7xaRTxcYPuoJnBy+a5pCpdLFFUa4qaWPEvF5d5WJesOtvNospEtvlDJJ\n\
|
||
EmftOHCCC4NcFxGizcIk4wS/YKlDmjQ0NuJ8bfYP83CqkP8+Pv+QRcdZb5hU1+ov\n\
|
||
pOIGfFRjczxkxCTPOqPj6JIhCmxIo93WP7fdKUBFYAnJG2dVCEPmApejJlNzFM7A\n\
|
||
otqlseFQ+W1mmpkzcV7sGDb4ej7xhC2YN+u9qMbSxrm1nh4RerXNU7HWD785ScSG\n\
|
||
lwIDAQAB\n\
|
||
-----END PUBLIC KEY-----";
|
||
|
||
const char* ch1 = "-----BEGIN PUBLIC KEY-----\n\
|
||
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAssBFYAQxvl3UxukRUKSQ\n\
|
||
+K/o925SAFeq4EkuGHbDYW3JtGznDBAbTigPgBRkYm5mTZoWFKBjyYRvtPNJCFHe\n\
|
||
gAxCmJnqgLELAdsMepBpRqsQQRhlIvCx2G8ppX4BrN+PMZvPMiAyjqL9Pt2ozvob\n\
|
||
Hguanc5T++8nx+sJ9S/s7jRZIaR8V3yHmSI0twAaaUKYWRejIXts3i827ObwOGaB\n\
|
||
qJSq+bEtMan3QeUUqsnnCZkSfQBHIaRPGFedgxQTGwP2//6efmKI4yY9ODNHd2na\n\
|
||
iLMZCLBNQaJZRK4/P7/RZriPzEAjXuQ6mEcIghJtNw7rpVI9GBZB48t8cUK0O8G8\n\
|
||
ewIDAQAB\n\
|
||
-----END PUBLIC KEY-----";
|
||
|
||
const char* ch2 = "-----BEGIN PUBLIC KEY-----\n\
|
||
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAx8yaQrjmL0uUWX+SQxXY\n\
|
||
obZXnJlxR6T3tpYyyHCVg11KhzUHY19Rw8NT8bSWR4JDsR/LdML2BR80d4RLxTsy\n\
|
||
qi0/LU03y1vKM6y86/4SFoPOyb1VWekq2MWoNmXzUr69I/7vYUIMIKvbZWoUyzYr\n\
|
||
ulpsb3J2DzrSvi2nvJ8TTTGe7VSpUC8d+v7hcL1jagRosiHI5fS3ni2V1xg+FBlO\n\
|
||
o/BK/IE6Zw8V7o/AjKRE06F5Ve/ou1UNyb9pqLMd1FcMywUPqSSSQkoiQGTknH5O\n\
|
||
BEn52fOPy6p1Vf3CIcaSVQeazg6cvACW0+mGkNWtFwHDr6z42sOGHMYxmZA2TAU3\n\
|
||
vQIDAQAB\n\
|
||
-----END PUBLIC KEY-----";
|
||
|
||
ionu_eyering_gen_rsa_challenge_pair (challenges, private_pem, public_pem);
|
||
printf ("%s\n", public_pem);
|
||
if (memcmp (ch, public_pem, strlen(ch)) != 0)
|
||
rc += testfailed ("Challenge keygen", challenges);
|
||
ionu_eyering_gen_rsa_challenge_pair (challenges1, private_pem, public_pem);
|
||
printf ("%s\n", public_pem);
|
||
if (memcmp (ch1, public_pem, strlen(ch1)) != 0)
|
||
rc += testfailed ("Challenge keygen", challenges1);
|
||
ionu_eyering_gen_rsa_challenge_pair (challenges2, private_pem, public_pem);
|
||
printf ("%s\n", public_pem);
|
||
if (memcmp (ch2, public_pem, strlen(ch2)) != 0)
|
||
rc += testfailed ("Challenge keygen", challenges2);
|
||
|
||
ionu_eyering_add_rsakey ("test/rsa.iks", "public", "key", public_pem, hi);
|
||
ionu_eyering_add_rsakey ("test/rsa.iks", "private", "key", private_pem, hi);
|
||
rbytes = ionu_eyering_pubkey_encrypt ("test/rsa.iks", "public", hi, bad, SL_AES_KEY_LEN, rsabuff);
|
||
rbytes = ionu_eyering_privatekey_decrypt ("test/rsa.iks", "private", hi, rsabuff, rbytes, rsabuff);
|
||
if (rbytes != SL_AES_KEY_LEN || memcmp (bad, rsabuff, SL_AES_KEY_LEN) != 0)
|
||
rc += testfailed ("ionu_eyering_privatekey_decrypt", "public+private");
|
||
else
|
||
printf ("ionu_eyering_pubkey_encrypt/privatekey_decrypt() pub+priv passed\n");
|
||
/*
|
||
ionu_eyering_get_key ("test/test.iks", "6a0ce1ec504b", kk, hi);
|
||
if (memcmp (kk, TGIkey, SL_AES_KEY_LEN) != 0)
|
||
rc += testfailed ("ionu_eyering_get_key", "TGI key");
|
||
else
|
||
printf ("ionu_eyering_get_key() TGI passed\n");
|
||
*/
|
||
ionu_eyering_get_key ("test/test.iks", "private", kk, hi);
|
||
if (memcmp (kk, PEM, 6) != 0)
|
||
rc += testfailed ("ionu_eyering_get_key", PEM);
|
||
else
|
||
printf ("ionu_eyering_get_key() RSA passed\n");
|
||
ionu_eyering_get_key ("test/test.iks", "perms", kk, bad);
|
||
if (memcmp (kk, PERMS, strlen(PERMS)) == 0)
|
||
rc += testfailed ("ionu_eyering_get_key()", "wrong password");
|
||
else
|
||
printf ("ionu_eyering_get_key() wrong password check passed\n");
|
||
// change the key
|
||
ionu_eyering_change_key ("test/test.iks", hi, bad);
|
||
ionu_eyering_get_key ("test/test.iks", "perms", kk, bad);
|
||
if (memcmp (kk, PERMS, strlen(PERMS)) != 0)
|
||
rc += testfailed ("ionu_eyering_get_key()", "after rekey");
|
||
else
|
||
printf ("ionu_eyering_get_key() after rekey check passed\n");
|
||
ionu_eyering_change_key ("test/test.iks", bad, hi);
|
||
/*
|
||
ionu_eyering_clear_tgi_cache ("test/test.iks", hi);
|
||
if (ionu_eyering_get_key ("test/test.iks", "TGI", kk, hi))
|
||
rc += testfailed ("ionu_eyering_get_key", "should not be any TGI keys left");
|
||
else
|
||
printf ("ionu_eyering_clear_tgi_cache() passed\n");
|
||
ionu_eyering_get_key ("test/test.iks", "perms", kk, hi);
|
||
if (memcmp (kk, PERMS, strlen(PERMS)) != 0)
|
||
rc += testfailed ("ionu_eyering_get_key", "perms JSON data");
|
||
else
|
||
printf ("ionu_eyering_get_key() JSON data passed\n");
|
||
*/
|
||
ionu_eyering_create ("test/tim.iks", "KeyRIng", "Local key ring", good);
|
||
ionu_eyering_add_strkey ("test/tim.iks", "keyringConfig", "EyeGlass", JSON, good);
|
||
ionu_eyering_get_key ("test/tim.iks", "keyringConfig", kk, good);
|
||
if (memcmp (kk, "{\"van\":{\"_id\":\"urn:sl:000000:::\",\"name\":\"TEST VAN\",\"vanPublic\"", 64) != 0)
|
||
rc += testfailed ("Huge JSON", (char*)kk);
|
||
else
|
||
printf ("Huge JSON test passed\n");
|
||
|
||
ionu_eyering_add_strkey ("test/tim.iks", "Sample", "do not duplicate", "0123456789abcdef", good);
|
||
ionu_eyering_add_strkey("test/tim.iks", "foo", "Replace Test", "bar", good);
|
||
ionu_eyering_get_key ("test/tim.iks", "foo", kk, good);
|
||
if (memcmp(kk, "bar", 4) != 0){
|
||
rc += testfailed ("foobar", (char*)kk);
|
||
}
|
||
ionu_eyering_add_strkey("test/tim.iks", "foo", "Replaced bar with newbar", "newbar", good);
|
||
int len = ionu_eyering_get_key_len ("test/tim.iks", "foo", good);
|
||
if (len != 7){
|
||
rc += testfailed ("eyering_get_key_len", "7");
|
||
}
|
||
ionu_eyering_get_key ("test/tim.iks", "foo", kk, good);
|
||
if (memcmp(kk, "newbar", 7) != 0){
|
||
rc += testfailed ("newbar", (char*)kk);
|
||
}
|
||
else {
|
||
printf ("update key passed\n");
|
||
}
|
||
ionu_eyering_remove_key("test/tim.iks", "foo", good);
|
||
if (ionu_eyering_get_key ("test/tim.iks", "foo", kk, good))
|
||
rc += testfailed ("ionu_eyering_remove_key", "foo");
|
||
ionu_eyering_get_key ("test/tim.iks", "Sample", kk, good);
|
||
if (memcmp(kk, "0123", 4) != 0){
|
||
rc += testfailed ("sample", (char*)kk);
|
||
}
|
||
|
||
ionu_derive_cgkey ("u3K2*l$qZ0a<", kk);
|
||
sequencelogic::GenerateCGKey ("u3K2*l$qZ0a<", aes, salt);
|
||
if (ionu_validate_cgkey ("u3K2*l$qZ0a<", (unsigned char*)kk))
|
||
printf ("CG key generate/validate passed\n");
|
||
else
|
||
rc += testfailed ("CG validate", "u3K2*l$qZ0a<");
|
||
if (ionu_validate_cgkey ("not good", (unsigned char*)kk))
|
||
rc += testfailed ("CG validate", "not good");
|
||
memset (kk + SL_AES_KEY_LEN, 85, SL_AES_KEY_LEN);
|
||
if (ionu_validate_cgkey ("u3K2*l$qZ0a<", (unsigned char*)kk))
|
||
rc += testfailed ("CG validate", "who passed the pepper?");
|
||
|
||
// Test the challenge response RSA key generation
|
||
ionu_eyering_create ("test/challenge.iks", "KeyRing", "Private key ring", good);
|
||
ionu_eyering_gen_rsa_challenge ("test/challenge.iks", "Unit", "test", challenges, good);
|
||
char* upk = ionu_eyering_get_pubkey ("test/challenge.iks", "Unit", good);
|
||
ionu_eyering_gen_rsa_challenge ("test/challenge.iks", "Laramie", "test", challenges1, good);
|
||
pk = ionu_eyering_get_pubkey ("test/challenge.iks", "Laramie", good);
|
||
if (sequencelogic::StrCmp (upk, pk) == 0)
|
||
rc += testfailed ("Laramie", "is not Boulder");
|
||
free (pk);
|
||
ionu_eyering_gen_rsa_challenge ("test/challenge.iks", "Cervelo", "test", challenges2, good);
|
||
pk = ionu_eyering_get_pubkey ("test/challenge.iks", "Cervelo", good);
|
||
if (sequencelogic::StrCmp (upk, pk) == 0)
|
||
rc += testfailed ("Nikki", "is not Cervelo");
|
||
free (pk);
|
||
ionu_eyering_gen_rsa_challenge ("test/challenge.iks", "Unit2", "test", challenges, good);
|
||
pk = ionu_eyering_get_pubkey ("test/challenge.iks", "Unit2", good);
|
||
if (sequencelogic::StrCmp (upk, pk) != 0)
|
||
rc += testfailed ("Challenge", "is not repeated");
|
||
free (pk);
|
||
free (upk);
|
||
ionu_eyering_gen_rsa_challenge ("test/challenge.iks", "JavaScript", "test to match JS implementation", "IOnU,Bob,Bob,Bob", good);
|
||
|
||
#ifdef JS
|
||
char hex[512];
|
||
rbytes = ionu_eyering_pubkey_encrypt ("test/challenge.iks", "JavaScript", good, (unsigned char*)"TGIkey 32 bytes", 16, rsabuff);
|
||
sequencelogic::BinaryToHex (rsabuff, rbytes, hex);
|
||
printf ("%s\n", hex);
|
||
rbytes = ionu_eyering_pubkey_encrypt ("test/challenge.iks", "JavaScript", good, (unsigned char*)"TGIkey 32 bytes", 16, rsabuff);
|
||
sequencelogic::BinaryToHex (rsabuff, rbytes, hex);
|
||
printf ("%s\n", hex);
|
||
rbytes = ionu_eyering_privatekey_decrypt ("test/challenge.iks", "JavaScript", good, rsabuff, rbytes, rsabuff);
|
||
printf ("%s\n", (char*)rsabuff);
|
||
char* mdhex = sequencelogic::DigestMessage ("sha256", (unsigned char*)"IOnU,Bob,Bob,Bob", 16);
|
||
printf ("%s\n", mdhex);
|
||
unsigned char hash[32];
|
||
sequencelogic::HexToBinary (mdhex, hash);
|
||
mdhex = sequencelogic::DigestMessage ("sha256", hash, 32);
|
||
printf ("%s\n", mdhex);
|
||
#endif
|
||
|
||
// Test EC public key encrypt/decrypt
|
||
unsigned char ecbuf[2048];
|
||
char plain[2048];
|
||
ionu_eyering_gen_ec_challenge_pair (challenges, private_pem, public_pem);
|
||
//printf ("%s\n", private_pem);
|
||
//printf ("%s\n", public_pem);
|
||
ionu_eyering_create ("test/ecdh.iks", "KeyRing", "Private key ring", good);
|
||
if (ionu_eyering_gen_ec_challenge ("test/ecdh.iks", "mine", "Mine", challenges, good))
|
||
printf ("Generated EC challenge pair\n");
|
||
if (ionu_eyering_gen_ec ("test/ecdh.iks", "peer", "Theirs", good))
|
||
printf ("Generated EC random pair\n");
|
||
bytes = ionu_eyering_ec_encrypt ("test/ecdh.iks", "mine", "peer", good, (unsigned char*)"Howdy we are having some fune now", 35, ecbuf);
|
||
//printf ("EC: PK encrypted %d bytes\n", (int)bytes);
|
||
bytes = ionu_eyering_ec_decrypt ("test/ecdh.iks", "peer", "mine", good, ecbuf, bytes, (unsigned char*)plain);
|
||
//printf ("EC: PK howdy %d bytes\n", (int)bytes);
|
||
if (bytes >= 35) {
|
||
if (strcmp (plain, "Howdy we are having some fune now") != 0)
|
||
rc += testfailed ("ionu_eyering_ec_decrypt", plain);
|
||
else
|
||
printf ("EC: %s, decrypted %d bytes\n", plain, (int)bytes);
|
||
}
|
||
else
|
||
rc += testfailed ("ionu_eyering_ec_encrypt", "Howdy");
|
||
|
||
if (!ionu_eyering_gen_rsa_challenge ("test/challenge.iks", "Unit3", "test", challenges3, good))
|
||
rc += testfailed ("ionu_eyering_gen_rsa_challenge", "Unit3");
|
||
if (!ionu_eyering_gen_rsa_challenge ("test/challenge.iks", "Unit4", "test", challenges4, good))
|
||
rc += testfailed ("ionu_eyering_gen_rsa_challenge", "Unit4");
|
||
if (!ionu_eyering_gen_rsa_challenge ("test/challenge.iks", "Unit5", "test", challenges5, good))
|
||
rc += testfailed ("ionu_eyering_gen_rsa_challenge", "Unit5");
|
||
if (!ionu_eyering_gen_rsa_challenge ("test/challenge.iks", "Unit6", "test", challenges6, good))
|
||
rc += testfailed ("ionu_eyering_gen_rsa_challenge", "Unit6");
|
||
if (!ionu_eyering_gen_rsa_challenge ("test/challenge.iks", "Unit7", "test", challenges7, good))
|
||
rc += testfailed ("ionu_eyering_gen_rsa_challenge", "Unit7");
|
||
if (!ionu_eyering_gen_rsa_challenge ("test/challenge.iks", "Unit8", "test", challenges8, good))
|
||
rc += testfailed ("ionu_eyering_gen_rsa_challenge", "Unit8");
|
||
if (!ionu_eyering_gen_rsa_challenge ("test/challenge.iks", "Unit9", "test", challenges9, good))
|
||
rc += testfailed ("ionu_eyering_gen_rsa_challenge", "Unit9");
|
||
if (!ionu_eyering_gen_rsa_challenge ("test/challenge.iks", "Unit10", "test", challenges10, good))
|
||
rc += testfailed ("ionu_eyering_gen_rsa_challenge", "Unit10");
|
||
if (!ionu_eyering_gen_rsa_challenge ("test/challenge.iks", "Unit11", "test", challenges11, good))
|
||
rc += testfailed ("ionu_eyering_gen_rsa_challenge", "Unit11");
|
||
if (!ionu_eyering_gen_rsa_challenge ("test/challenge.iks", "Unit12", "test", challenges12, good))
|
||
rc += testfailed ("ionu_eyering_gen_rsa_challenge", "Unit12");
|
||
if (!ionu_eyering_gen_rsa_challenge ("test/challenge.iks", "too short", "test", shortchallenge, good))
|
||
rc += testfailed ("ionu_eyering_gen_rsa_challenge", "too short");
|
||
if (!ionu_eyering_gen_rsa_challenge ("test/challenge.iks", "super short", "test", supershortchallenge, good))
|
||
rc += testfailed ("ionu_eyering_gen_rsa_challenge", "super short");
|
||
rbytes = ionu_eyering_pubkey_encrypt ("test/challenge.iks", "Unit", good, bad, SL_AES_KEY_LEN, rsabuff);
|
||
rbytes = ionu_eyering_privatekey_decrypt ("test/challenge.iks", "Unit", good, rsabuff, rbytes, rsabuff);
|
||
if (rbytes != SL_AES_KEY_LEN || memcmp (bad, rsabuff, SL_AES_KEY_LEN) != 0)
|
||
rc += testfailed ("ionu_eyering_privatekey_decrypt", "Cloudgaurd");
|
||
else
|
||
printf ("challenge pubkey_encrypt/privatekey_decrypt() passed\n");
|
||
|
||
if (ionu_eyering_get_key ("test/ionu-keyring.iks", "devicePrivate", kk, good))
|
||
rc += testfailed ("devicePrivate", (char*)kk);
|
||
ionu_eyering_create (NULL, "bad", "Bad key tests", NULL);
|
||
ionu_eyering_create ("/garbonzo-beans/what.iks", "bad", "Bad key tests", hi);
|
||
ionu_eyering_create ("test/bad.iks", NULL, NULL, hi);
|
||
ionu_eyering_create ("test/bad.iks", (char*)bad, "Bad key tests", hi);
|
||
ionu_eyering_create ("test/bad.iks", "bad", (char*)bad, hi);
|
||
ionu_eyering_create ("test/bad.iks", "bad", "Bad key tests", hi);
|
||
ionu_eyering_add_binkey ("junkpathtest/test.iks", "AES", "Random AES key", SL_AES_KEY_LEN, kk, hi);
|
||
ionu_eyering_gen_rsa (empty_iks, "CloudGuard", "RSA keypair", hi);
|
||
ionu_eyering_add_strkey(empty_iks, "foo", "Replaced bar with newbar", "newbar", hi);
|
||
ionu_eyering_add_rsakey ("test/bad.iks", "public", "key", NULL, hi);
|
||
ionu_eyering_add_rsakey ("test/rsa.iks", "private", "key", "---RSA PRIVATE", hi);
|
||
rbytes = ionu_eyering_pubkey_encrypt ("test/rsa.iks", "public", hi, bad, SL_AES_KEY_LEN, rsabuff);
|
||
rbytes = ionu_eyering_privatekey_decrypt ("test/rsa.iks", "private", hi, rsabuff, rbytes, rsabuff);
|
||
if (rbytes == SL_AES_KEY_LEN || memcmp (bad, rsabuff, SL_AES_KEY_LEN) == 0)
|
||
rc += testfailed ("ionu_eyering_privatekey_decrypt", "bad");
|
||
|
||
if (rc == 0)
|
||
printf ("\nKeyring tests passed\n-------------------------------\n");
|
||
else
|
||
printf ("\n%d Keyring tests failed\n-------------------------------\n", rc);
|
||
|
||
return rc;
|
||
}
|
||
|
||
void IOnUKeyDerive (const char* password)
|
||
{
|
||
unsigned char key[SL_AES_KEY_LEN];
|
||
char hex[SL_AES_KEY_LEN * 2 + 1];
|
||
ionu_derive_key (password, key);
|
||
sequencelogic::Base64Encode (key, SL_AES_KEY_LEN, hex);
|
||
printf ("%0.2f <%s> %s\n", ionu_password_strength (password), password, hex);
|
||
if (strcmp (password, "Hi") == 0 && strcmp (hex, "9Hyf4kupGoPEv3qf6APiiOs29gJEKIbc4DVzylmxmT0=") != 0)
|
||
printf ("***************** DATA WIPE REQUIRED, PASSWORD KEY DERIVATION CHANGES VALUES *****************\n");
|
||
}
|
||
|
||
int IOnUPasswordTests()
|
||
{
|
||
int rc = 0;
|
||
unsigned char userkey[SL_AES_KEY_LEN];
|
||
unsigned char cghkey[SL_AES_KEY_LEN*2];
|
||
unsigned char tgikey[SL_AES_KEY_LEN];
|
||
unsigned char testkey[SL_AES_KEY_LEN];
|
||
char hex[SL_AES_KEY_LEN * 2 + 1];
|
||
sequencelogic::DeriveKey ("madman12", userkey);
|
||
const char* cghk = "fwHi1hYx6wMXSQKxRexqu23ngeBM7ccmKwie0ddkAakNLKV/J9NLjYUzZqOFqllm5pFp8GIdsS5/67ewZyUiYw==";
|
||
size_t cghkLength = sequencelogic::Base64Decode (cghk, cghkey);
|
||
if (cghkLength != 2 * SL_AES_KEY_LEN)
|
||
rc += testfailed ("CGHK: expected 64 bytes\n", "oops");
|
||
|
||
sequencelogic::XorKeys (userkey, cghkey, tgikey, SL_AES_KEY_LEN);
|
||
sequencelogic::Base64Encode (tgikey, SL_AES_KEY_LEN, hex);
|
||
printf ("TGI key: %s\n", hex);
|
||
sequencelogic::XorKeys (tgikey, cghkey, testkey, SL_AES_KEY_LEN);
|
||
if (sequencelogic::MemCmp (testkey, userkey, SL_AES_KEY_LEN) != 0)
|
||
rc += testfailed ("XOR key test", "user");
|
||
|
||
IOnUKeyDerive ("password");
|
||
IOnUKeyDerive ("admin");
|
||
IOnUKeyDerive ("qwerty");
|
||
IOnUKeyDerive ("H");
|
||
IOnUKeyDerive ("Hi");
|
||
IOnUKeyDerive ("Hello");
|
||
IOnUKeyDerive ("He11o");
|
||
IOnUKeyDerive ("H3ll0");
|
||
IOnUKeyDerive ("12345678");
|
||
IOnUKeyDerive ("123456789");
|
||
IOnUKeyDerive ("madman12");
|
||
IOnUKeyDerive ("ijfijfijf");
|
||
IOnUKeyDerive ("ijfIjfijf*");
|
||
IOnUKeyDerive ("@bCd1960");
|
||
IOnUKeyDerive ("Abcd1960");
|
||
IOnUKeyDerive ("gonefishing1125");
|
||
IOnUKeyDerive ("LeeAnn82994");
|
||
IOnUKeyDerive ("Lee@nn82994");
|
||
IOnUKeyDerive ("GeekBand2013");
|
||
IOnUKeyDerive ("u3K2*l");
|
||
IOnUKeyDerive ("u3K2*l$");
|
||
IOnUKeyDerive ("u3K2*l$q");
|
||
IOnUKeyDerive ("u3K2*l$qZ");
|
||
IOnUKeyDerive ("u3K2*l$qZ0");
|
||
IOnUKeyDerive ("u3K2*l$qZ0a");
|
||
IOnUKeyDerive ("u3K2*l$qZ0a<");
|
||
IOnUKeyDerive ("areallyveryextrasuperduperhugelylongAndSTOOPIDpassword*l$qZ0a<so long\nand full of Gar@#$e");
|
||
|
||
std::string madman12 ("6EVdXfSkSX+I15ZXGCRRH4TnpBnt17ivih5Nd7DxkPQ=");
|
||
std::string ijfijfijf ("V4DnZwzZO+0GLuH0GMj8QZC3dhn4/HIJZvKAtdg2RQk=");
|
||
std::string slow = sequencelogic::SlowHash ("madman12", "");
|
||
cout << slow << endl;
|
||
std::string validate = sequencelogic::SlowHash ("madman12", slow);
|
||
if (slow != validate)
|
||
rc += testfailed ("sequencelogic::SlowHash", "Validation failed");
|
||
validate = sequencelogic::SlowHash ("madman12", madman12);
|
||
if (validate.size() == 0)
|
||
rc += testfailed ("sequencelogic::SlowHash", "Validation of madman12 failed");
|
||
validate = sequencelogic::SlowHash ("ijfijfijf", ijfijfijf);
|
||
if (validate.size() == 0)
|
||
rc += testfailed ("sequencelogic::SlowHash", "Validation of ijfijfijf failed");
|
||
validate = sequencelogic::SlowHash ("madman12", ijfijfijf);
|
||
if (validate.size() != 0)
|
||
rc += testfailed ("sequencelogic::SlowHash", "inValidation of ijfijfijf failed");
|
||
if (rc == 0)
|
||
printf ("Password tests passed\n");
|
||
|
||
return rc;
|
||
}
|
||
|
||
int TestSetSize()
|
||
{
|
||
int rc = 0;
|
||
/*
|
||
Key tgi ("tgi", "stream", SL_AES_KEY_LEN, TGIkey, Key::AES);
|
||
EyeContainer* IOnU = NULL;
|
||
std::string sentry = "stream";
|
||
std::streamoff ssize = 0;
|
||
size_t nread = 0;
|
||
char pbuff[4096]; // Pattern buffer
|
||
char vbuff[4096]; // Verify buffer
|
||
char zbuff[4096]; // Zeros buffer
|
||
memset (zbuff, 0, 4096);
|
||
memset (pbuff, '1', 4096);
|
||
|
||
// Create stream via SetStreamSize, set a size, check that expansion padding is ok
|
||
IOnU = new EyeContainer("test/setsize.ionu", tgi, URN, PERMS);
|
||
IOnU->SetStreamSize (sentry, 0);
|
||
if (IOnU->GetStreamSize (sentry) != 0)
|
||
rc += testfailed ("SetStreamSize", "expected 0 size");
|
||
IOnU->SetStreamSize (sentry, 4096);
|
||
if (IOnU->GetStreamSize (sentry) != 4096)
|
||
rc += testfailed ("SetStreamSize", "expected 4096 size");
|
||
IOnU->Finalize();
|
||
delete IOnU;
|
||
IOnU = new EyeContainer("test/setsize.ionu", tgi, ios::in);
|
||
ssize = IOnU->GetStreamSize (sentry);
|
||
IOnU->ReadStream (sentry, 0, vbuff, 4096, &nread);
|
||
if (ssize != 4096 || nread != 4096)
|
||
rc += testfailed ("SetStreamSize", "expected 4096 bytes");
|
||
else if (memcmp (zbuff, vbuff, 4096) != 0)
|
||
rc += testfailed ("SetStreamSize", "expected 4096 0's");
|
||
delete IOnU;
|
||
|
||
// Create an alternating pattern of real writes and expansion padding
|
||
IOnU = new EyeContainer("test/setsize.ionu", tgi, ios::out);
|
||
for (ssize = 0; ssize < 5*IONU_MEGA_BYTES; ssize += 8192) {
|
||
IOnU->WriteStream (sentry, ssize, pbuff, 4096, &nread);
|
||
IOnU->SetStreamSize (sentry, ssize + 8192);
|
||
}
|
||
IOnU->Finalize();
|
||
delete IOnU;
|
||
IOnU = new EyeContainer("test/setsize.ionu", tgi, ios::in);
|
||
ssize = IOnU->GetStreamSize (sentry);
|
||
if (ssize != IONU_MEGA_BYTES)
|
||
rc += testfailed ("SetStreamSize", "expected 1MB size");
|
||
for (ssize = 0; ssize < IONU_MEGA_BYTES; ssize += 8192) {
|
||
IOnU->ReadStream (sentry, ssize, vbuff, 4096, &nread);
|
||
if (nread != 4096 || memcmp (pbuff, vbuff, 4096) != 0)
|
||
rc += testfailed ("Alternating", "expected 4096 1's");
|
||
IOnU->ReadStream (sentry, ssize + 4096, vbuff, 4096, &nread);
|
||
if (nread != 4096 || memcmp (zbuff, vbuff, 4096) != 0)
|
||
rc += testfailed ("Alternating", "expected 4096 0's");
|
||
}
|
||
delete IOnU;
|
||
|
||
if (rc == 0)
|
||
printf ("SetSize tests passed\n");
|
||
*/
|
||
return rc;
|
||
}
|
||
int TestStreams()
|
||
{
|
||
printf ("\nEyeStream tests\n-------------------------------\n");
|
||
int rc = 0;
|
||
/*
|
||
#ifdef OBSOLETE
|
||
size_t n = 0;
|
||
EyeContainer* IOnU = NULL;
|
||
char ebuff[4096];
|
||
char sbuff[4096];
|
||
std::string txtmsg;
|
||
Key tgi ("tgi", "stream", SL_AES_KEY_LEN, TGIkey, Key::AES);
|
||
|
||
std::streamoff eyebigsize (8*1024*1024);
|
||
#ifdef LIN64
|
||
EyeHeader eyehead;
|
||
eyehead.SetFileSize (eyebigsize);
|
||
if (eyehead.GetFileSize() != eyebigsize) {
|
||
std::stringstream ss;
|
||
ss << eyebigsize << " != " << eyehead.GetFileSize();
|
||
rc += testfailed ("EyeHeader.SetStreamSize ", ss.str());
|
||
}
|
||
#endif
|
||
|
||
IOnU = new EyeContainer("test/stream.ionu", tgi, URN, PERMS);
|
||
printf ("Created\n");
|
||
memset (sbuff, '1', 4096);
|
||
memset (sbuff, 'a', 64);
|
||
memset (sbuff+64, 'b', 64);
|
||
memset (sbuff+128, 'c', 64);
|
||
memset (sbuff+192, 'd', 64);
|
||
memset (sbuff+256, 'e', 64);
|
||
memset (sbuff+320, 'f', 64);
|
||
memset (sbuff+384, 'g', 64);
|
||
memset (sbuff+448, 'h', 64);
|
||
IOnU->AddMemoryFile ("stream", (unsigned char*)sbuff, 512, "test/stream");
|
||
IOnU->Finalize();
|
||
delete IOnU;
|
||
printf ("Closed\n");
|
||
IOnU = new EyeContainer("test/stream.ionu", tgi, ios::in);
|
||
printf ("Opened\n");
|
||
cout << IOnU->GetMetaData() << endl;
|
||
delete IOnU;
|
||
printf ("Closed\n");
|
||
EyeStream wty ("test/stream.ionu", tgi, "stream");
|
||
printf ("opened as stream\n");
|
||
wty.read (ebuff, 512);
|
||
if (memcmp (sbuff, ebuff, 512) != 0)
|
||
cout << "Error" << endl;
|
||
else
|
||
cout << "Stream read passed" << endl;
|
||
printf ("read 512\n");
|
||
memset (sbuff, 'o', 512);
|
||
wty.write (16, sbuff, 64, &n);
|
||
printf ("wrote 64\n");
|
||
//wty.write (512, sbuff, 64, &n);
|
||
wty.close();
|
||
printf ("close stream\n");
|
||
wty.open ("test/stream.ionu", tgi, "stream");
|
||
eyebigsize = 5;
|
||
wty.read (ebuff, 512);
|
||
txtmsg.assign ((char*)ebuff, 81);
|
||
cout << txtmsg << endl;
|
||
wty.read (eyebigsize, ebuff, 51, &n);
|
||
txtmsg.assign ((char*)ebuff, 51);
|
||
cout << txtmsg << endl;
|
||
wty.read (ebuff, 512);
|
||
txtmsg.assign ((char*)ebuff, 81);
|
||
cout << txtmsg << endl;
|
||
wty.close();
|
||
IOnU = new EyeContainer("test/stream.ionu", tgi);
|
||
txtmsg = IOnU->GetTextMessage ("stream");
|
||
if (txtmsg.size() != 512)
|
||
cout << "Expected 512 got " << txtmsg.size() << endl;
|
||
else
|
||
cout << txtmsg << endl;
|
||
delete IOnU;
|
||
|
||
cout << "TestStreams() - wrote " << n << endl;
|
||
wty.read (0, ebuff, 81, &n);
|
||
txtmsg.assign (ebuff, 81);
|
||
cout << txtmsg << endl;
|
||
wty.close();
|
||
|
||
cout << "big stream test" << endl;
|
||
|
||
#define SMALL
|
||
#ifdef SMALL
|
||
wty.open ("test/stream.ionu", tgi, "stream");
|
||
wty.write (sbuff, 2048);
|
||
wty.write (sbuff+2048, 2048);
|
||
wty.close();
|
||
#else
|
||
wty.open ("test/stream.ionu", tgi, "stream");
|
||
for (int i = 0; i < 2048*1024; ++i)
|
||
wty.write (sbuff, 4096);
|
||
wty.close();
|
||
#endif
|
||
|
||
IOnU = new EyeContainer("test/stream.ionu", tgi);
|
||
txtmsg = IOnU->GetTextMessage ("stream");
|
||
if (txtmsg.size() != 4096)
|
||
cout << "Expected 4096 got " << txtmsg.size() << endl;
|
||
else
|
||
cout << "read 4096" << endl;
|
||
delete IOnU;
|
||
|
||
wty.open ("test/stream.ionu", tgi, "stream");
|
||
wty.read (sbuff, 2048);
|
||
txtmsg.assign (sbuff, 64);
|
||
cout << txtmsg << endl;
|
||
wty.read (sbuff, 2048);
|
||
txtmsg.assign (sbuff, 64);
|
||
cout << txtmsg << endl;
|
||
wty.close();
|
||
|
||
ionu_eyefile_create_with_message ("test/stream.ionu", TGIkey, "stream", "Yo there Alan Frost, what are you up to!", 40, URN, PERMS);
|
||
EyeStream tty ("test/stream.ionu", tgi, "stream");
|
||
tty.read (ebuff, 37);
|
||
std::string tee (ebuff, 37);
|
||
std::cout << tee << std::endl;
|
||
tty.read (4, ebuff, 33, &n);
|
||
tee.assign (ebuff, n);
|
||
std::cout << tee << std::endl;
|
||
tty.read (24, ebuff, 33, &n);
|
||
tee.assign (ebuff, n);
|
||
std::cout << tee << std::endl;
|
||
tty.read (44, ebuff, 33, &n);
|
||
tee.assign (ebuff, n);
|
||
std::cout << tee << std::endl;
|
||
tty.seekg (0);
|
||
tty.read (ebuff, 13);
|
||
tee.assign (ebuff, 13);
|
||
tty.read (ebuff, 13);
|
||
tee.append (ebuff, 13);
|
||
tty.read (ebuff, 13);
|
||
tee.append (ebuff, 13);
|
||
tty.read (ebuff, 13);
|
||
//tee.append (ebuff, 13);
|
||
std::cout << tee << std::endl;
|
||
|
||
printf ("----------------------------------------------\n");
|
||
IOnU = new EyeContainer("test/stream.ionu", tgi, URN, PERMS);
|
||
IOnU->AddMemoryFile ("stream", (unsigned char*)"This stream is 28 bytes long", 28, "test/streaming");
|
||
IOnU->Finalize();
|
||
delete IOnU;
|
||
cout << EyeContainer::GetMetaData ("test/stream.ionu", ".ionumeta", tgi) << endl;
|
||
|
||
EyeStream efile ("test/stream.ionu", tgi, URN, PERMS, "stream");
|
||
efile.write ("This stream is 28 bytes long", 28);
|
||
efile.close();
|
||
IOnU = new EyeContainer("test/stream.ionu", tgi);
|
||
cout << IOnU->GetMetaData() << endl;
|
||
cout << IOnU->GetTextMessage ("stream") << endl;
|
||
delete IOnU;
|
||
|
||
efile.open ("test/stream.ionu", tgi, URN, PERMS, "stream");
|
||
efile.write ("This stream is", 14);
|
||
efile.write (" 28 bytes long", 14);
|
||
efile.close();
|
||
IOnU = new EyeContainer("test/stream.ionu", tgi);
|
||
cout << IOnU->GetMetaData() << endl;
|
||
cout << IOnU->GetTextMessage ("stream") << endl;
|
||
delete IOnU;
|
||
|
||
//efile.open ("test/stream.ionu", tgi, URN, PERMS, "stream");
|
||
efile.open ("test/stream.ionu", tgi, "stream");
|
||
efile.write ("This is my stream", 17);
|
||
efile.write (", this is your stream", 22);
|
||
efile.close();
|
||
IOnU = new EyeContainer("test/stream.ionu", tgi);
|
||
cout << IOnU->GetMetaData() << endl;
|
||
cout << IOnU->GetPermissions() << endl;
|
||
txtmsg = IOnU->GetTextMessage ("stream");
|
||
if (txtmsg.size() > 0)
|
||
cout << "<" << txtmsg << ">" << endl;
|
||
else
|
||
printf ("Failed to find stream\n");
|
||
delete IOnU;
|
||
|
||
IOnU = new EyeContainer("test/stream.ionu", tgi);
|
||
cout << IOnU->GetMetaData() << endl;
|
||
delete IOnU;
|
||
efile.open ("test/stream.ionu", tgi, "stream");
|
||
efile.seekg (19);
|
||
efile.read (ebuff, 19);
|
||
std::string ee (ebuff, 19);
|
||
std::cout << ee << std::endl;
|
||
efile.read (0, ebuff, 40, &n);
|
||
cout << "read " << n << " of requested 40 bytes" << endl;
|
||
strcpy (ebuff, "a garbage stream");
|
||
efile.write (8, ebuff, 16, &n);
|
||
efile.read (10, ebuff, 14, &n);
|
||
efile.dump();
|
||
ee.assign (ebuff, 14);
|
||
std::cout << ee << std::endl;
|
||
efile.open ("test/badstream.ionu", tgi, "stream");
|
||
if (efile.is_open())
|
||
rc += testfailed ("efile.is_open", "test/badstream.ionu");
|
||
efile.flush();
|
||
efile.close();
|
||
|
||
efile.open ("test/stream.ionu", tgi, "stream");
|
||
efile.setsize (100);
|
||
cout << efile.getsize() << endl;
|
||
efile.write ("The stream is larger than this", 30);
|
||
efile.close();
|
||
IOnU = new EyeContainer("test/stream.ionu", tgi);
|
||
txtmsg = IOnU->GetTextMessage ("stream");
|
||
if (txtmsg.size() != 130)
|
||
cout << "Expected 130 got " << txtmsg.size() << endl;
|
||
else
|
||
cout << txtmsg << endl;
|
||
delete IOnU;
|
||
|
||
efile.open ("test/stream.ionu", tgi, "stream");
|
||
efile.write ("The stream is larger than this", 30);
|
||
efile.setsize (20);
|
||
cout << efile.getsize() << endl;
|
||
efile.close();
|
||
IOnU = new EyeContainer("test/stream.ionu", tgi);
|
||
txtmsg = IOnU->GetTextMessage ("stream");
|
||
if (txtmsg.size() != 20)
|
||
cout << "Expected 20 got " << txtmsg.size() << endl;
|
||
else
|
||
cout << txtmsg << endl;
|
||
delete IOnU;
|
||
|
||
efile.open ("test/stream.ionu", tgi, "stream");
|
||
efile.setsize (1*1024*1024);
|
||
efile.write ("This a 2MB stream padded out t", 30);
|
||
cout << efile.getsize() << endl;
|
||
efile.close();
|
||
efile.open ("test/stream.ionu", tgi, "stream");
|
||
cout << efile.getsize() << endl;
|
||
efile.read (10, ebuff, 14, &n);
|
||
ee.assign (ebuff, 14);
|
||
std::cout << ee << std::endl;
|
||
efile.close();
|
||
|
||
efile.open ("test/stream.ionu", tgi, "stream");
|
||
efile.setsize (65536*2);
|
||
cout << efile.getsize() << endl;
|
||
efile.setsize (20);
|
||
efile.write ("The stream is larger than this", 30);
|
||
cout << efile.getsize() << endl;
|
||
efile.rename ("tstream");
|
||
efile.close();
|
||
IOnU = new EyeContainer("test/stream.ionu", tgi);
|
||
txtmsg = IOnU->GetTextMessage ("tstream");
|
||
if (txtmsg.size() != 30)
|
||
cout << "Expected 30 got " << txtmsg.size() << endl;
|
||
else
|
||
cout << txtmsg << endl;
|
||
delete IOnU;
|
||
if (rc == 0)
|
||
printf ("\nStream tests passed\n-------------------------------\n");
|
||
else
|
||
printf ("\n%d Stream tests failed\n-------------------------------\n", rc);
|
||
#endif
|
||
*/
|
||
return rc;
|
||
}
|
||
|
||
int TestP2P()
|
||
{
|
||
printf ("\nP2P tests\n-------------------------------\n");
|
||
int rc = 0;
|
||
/*
|
||
size_t bytes = 0;
|
||
EyeBytes msg;
|
||
unsigned char* cmd;
|
||
std::string arg;
|
||
std::string meta;
|
||
std::vector<std::string> args;
|
||
Keyring ring ("testring", "Test Key Ring");
|
||
ring.GenerateRSAKey("Client", "RSA keypair");
|
||
ring.GenerateRSAKey("Peer", "RSA keypair");
|
||
ring.GenerateRSAKey("CG", "RSA keypair");
|
||
char* pk = ring.GetPubKey ("Client");
|
||
Key clientpubkey ("client", "public key", (int)strlen(pk), (const unsigned char*) pk, Key::RSA_PUBLIC);
|
||
delete[] pk;
|
||
pk = ring.GetPubKey ("Peer");
|
||
Key peerpubkey ("peer", "public key", (int)strlen(pk), (const unsigned char*) pk, Key::RSA_PUBLIC);
|
||
delete[] pk;
|
||
pk = ring.GetPubKey ("CG");
|
||
Key cgpubkey ("CG", "public key", (int)strlen(pk), (const unsigned char*) pk, Key::RSA_PUBLIC);
|
||
delete[] pk;
|
||
|
||
EyeConnection::MESSAGE_CODE mc;
|
||
EyeConnection client (URN2, ring.GetKey ("Client"), &peerpubkey);
|
||
EyeConnection peer (URN1, ring.GetKey ("Peer"), &clientpubkey);
|
||
EyeConnection cg (URN1, ring.GetKey ("CG"), &clientpubkey);
|
||
if (! client.ClientHello (msg))
|
||
rc += testfailed ("EyeConnection::ClientHello", "uh oh");
|
||
cout << "client state " << client.GetState() << endl;
|
||
//while (client.GetState() != EyePeer::FINISHED && peer.GetState() != EyePeer::FINISHED) {
|
||
mc = peer.Receive (msg.GetBytes(), msg.GetSize(), msg);
|
||
cout << mc << " peer state " << peer.GetState() << endl;
|
||
mc = client.Receive (msg.GetBytes(), msg.GetSize(), msg);
|
||
cout << mc << " client state " << client.GetState() << endl;
|
||
//}
|
||
mc = peer.Receive (msg.GetBytes(), msg.GetSize(), msg);
|
||
cout << mc << " peer state " << peer.GetState() << endl;
|
||
// mc = client.Receive (msg.GetBytes(), msg.GetSize(), msg);
|
||
//cout << "client state " << client.GetState() << endl;
|
||
cmd = client.Send (EyeConnection::DATA, (const unsigned char*)"P2P test message", 17, &bytes);
|
||
mc = peer.Receive (cmd, bytes, msg);
|
||
cout << mc << endl;
|
||
delete[] cmd;
|
||
cout << msg.GetString() << endl;
|
||
client.Dump();
|
||
peer.Dump();
|
||
cmd = peer.Send (EyeConnection::DATA, (const unsigned char*)"F2F test message", 17, &bytes);
|
||
mc = client.Receive (cmd, bytes, msg);
|
||
cout << mc << endl;
|
||
delete[] cmd;
|
||
cout << msg.GetString() << endl;
|
||
arg = "test/*.ionu";
|
||
cmd = peer.Command (EyeConnection::LIST, arg, &bytes);
|
||
mc = client.Receive (cmd, bytes, msg);
|
||
cout << mc << endl;
|
||
delete[] cmd;
|
||
mc = peer.Receive (msg.GetBytes(), msg.GetSize(), msg);
|
||
cout << mc << endl;
|
||
meta.assign ((char*)msg.GetBytes(), msg.GetSize());
|
||
cout << meta << endl;
|
||
arg = "test.ionu";
|
||
cmd = peer.Command (EyeConnection::GET, arg, &bytes);
|
||
mc = client.Receive (cmd, bytes, msg);
|
||
cout << mc << endl;
|
||
delete[] cmd;
|
||
mc = peer.Receive (msg.GetBytes(), msg.GetSize(), msg);
|
||
if (mc != EyeConnection::RETCODE || msg.GetByte(0) == 0) {
|
||
rc += testfailed ("EyeConnection::GET", arg);
|
||
cout << mc << endl;
|
||
}
|
||
arg = cionu;
|
||
cmd = peer.Command (EyeConnection::HEAD, arg, &bytes);
|
||
mc = client.Receive (cmd, bytes, msg);
|
||
cout << mc << endl;
|
||
delete[] cmd;
|
||
mc = peer.Receive (msg.GetBytes(), msg.GetSize(), msg);
|
||
cout << mc << endl;
|
||
meta.assign ((char*)msg.GetBytes(), msg.GetSize());
|
||
cout << meta << endl;
|
||
cmd = peer.Command (EyeConnection::GET, arg, &bytes);
|
||
mc = client.Receive (cmd, bytes, msg);
|
||
cout << mc << endl;
|
||
delete[] cmd;
|
||
mc = peer.Receive (msg.GetBytes(), msg.GetSize(), msg);
|
||
if (mc != EyeConnection::DATA) {
|
||
rc += testfailed ("EyeConnection::GET", arg);
|
||
cout << mc << endl;
|
||
}
|
||
args.push_back (cionu);
|
||
args.push_back ("alan");
|
||
args.push_back ("W");
|
||
cmd = peer.Command (EyeConnection::LOCK, args, &bytes);
|
||
mc = client.Receive (cmd, bytes, msg);
|
||
cout << mc << endl;
|
||
delete[] cmd;
|
||
mc = peer.Receive (msg.GetBytes(), msg.GetSize(), msg);
|
||
if (mc == EyeConnection::RETCODE && msg.GetByte(0) == 0)
|
||
cout << "Lock succeeded" << endl;
|
||
args.pop_back ();
|
||
cmd = peer.Command (EyeConnection::UNLOCK, args, &bytes);
|
||
mc = client.Receive (cmd, bytes, msg);
|
||
cout << mc << endl;
|
||
delete[] cmd;
|
||
mc = peer.Receive (msg.GetBytes(), msg.GetSize(), msg);
|
||
if (mc == EyeConnection::RETCODE && msg.GetByte(0) == 0)
|
||
cout << "Unlock succeeded" << endl;
|
||
cmd = peer.Send (EyeConnection::SUSPEND, (const unsigned char*)"suspend", 7, &bytes);
|
||
mc = client.Receive (cmd, bytes, msg);
|
||
if (mc == EyeConnection::SUSPEND)
|
||
cout << "Client suspended" << endl;
|
||
delete[] cmd;
|
||
mc = peer.Receive (msg.GetBytes(), msg.GetSize(), msg);
|
||
if (mc == EyeConnection::RETCODE && msg.GetByte(0) == 0)
|
||
cout << "Suspend succeeded" << endl;
|
||
cmd = peer.Send (EyeConnection::RESUME, (const unsigned char*)"suspend", 7, &bytes);
|
||
mc = client.Receive (cmd, bytes, msg);
|
||
cout << mc << endl;
|
||
delete[] cmd;
|
||
mc = peer.Receive (msg.GetBytes(), msg.GetSize(), msg);
|
||
if (mc == EyeConnection::RETCODE && msg.GetByte(0) == 0)
|
||
cout << "Resume succeeded" << endl;
|
||
client.Dump();
|
||
peer.Dump();
|
||
if (rc == 0)
|
||
printf ("\nP2P tests passed\n-------------------------------\n");
|
||
else
|
||
printf ("\n%d P2P tests failed\n-------------------------------\n", rc);
|
||
*/
|
||
return rc;
|
||
}
|
||
|
||
int TestMixedUpKeys()
|
||
{
|
||
printf ("\nMixed up key tests\n-------------------------------\n");
|
||
int rc = 0;
|
||
/*
|
||
std::string sentry ("stream");
|
||
size_t written = 0;
|
||
std::string sb;
|
||
char sbuffer[1024];
|
||
Key junk;
|
||
EyeContainer* mixup = new EyeContainer("test/mixup.ionu", TGIkey, URN, PERMS);
|
||
std::streamoff spos = 0;
|
||
mixup->WriteStream (sentry, spos, "This is a streaming video test s", 32, &written);
|
||
spos = 32;
|
||
mixup->WriteStream (sentry, spos, "tream not really", 16, &written);
|
||
mixup->Finalize();
|
||
delete mixup;
|
||
cout << EyeContainer::GetContentMetaData ("test/mixup.ionu", "stream", junk) << endl;
|
||
|
||
mixup = new EyeContainer("test/mixup.ionu", TGIkey);
|
||
spos = 0;
|
||
mixup->ReadStream (sentry, spos, sbuffer, 48, &written);
|
||
sb.assign (sbuffer, written);
|
||
delete mixup;
|
||
if (written != 48 && sb.compare ("This is a streaming video test stream not really") != 0)
|
||
rc += testfailed ("Mixup readstream ios::in", sb);
|
||
|
||
mixup = new EyeContainer("test/mixup.ionu", TGIkey, ios::in);
|
||
spos = 0;
|
||
mixup->ReadStream (sentry, spos, sbuffer, 48, &written);
|
||
sb.assign (sbuffer, written);
|
||
delete mixup;
|
||
if (written != 48 && sb.compare ("This is a streaming video test stream not really") != 0)
|
||
rc += testfailed ("Mixup readstream ios::in", sb);
|
||
|
||
mixup = new EyeContainer("test/mixup.ionu", badkey);
|
||
spos = 0;
|
||
mixup->WriteStream (sentry, spos, "trash", 5, &written);
|
||
mixup->Finalize();
|
||
delete mixup;
|
||
if (written != 0)
|
||
rc += testfailed ("Mixup writestream", "trash");
|
||
|
||
mixup = new EyeContainer("test/mixup.ionu", badkey);
|
||
spos = 32;
|
||
mixup->WriteStream (sentry, spos, "tream yes it is!", 16, &written);
|
||
mixup->Finalize();
|
||
delete mixup;
|
||
if (written != 0)
|
||
rc += testfailed ("Mixup writestream", "tream yes it is!");
|
||
|
||
mixup = new EyeContainer("test/mixup.ionu", TGIkey);
|
||
spos = 0;
|
||
mixup->ReadStream (sentry, spos, sbuffer, 48, &written);
|
||
sb.assign (sbuffer, written);
|
||
delete mixup;
|
||
if (written != 48 && sb.compare ("This is a streaming video test stream not really") != 0)
|
||
rc += testfailed ("Mixup readstream after bad writes", sb);
|
||
|
||
spos = 0;
|
||
mixup = new EyeContainer("test/mixup.ionu", badkey);
|
||
mixup->ReadStream (sentry, spos, sbuffer, 48, &written);
|
||
sb.assign (sbuffer, written);
|
||
delete mixup;
|
||
if (written != 0)
|
||
rc += testfailed ("Mixup readstream with bad key", sb);
|
||
|
||
mixup = new EyeContainer("test/mixup.ionu", badkey);
|
||
unsigned char* ex = mixup->ExtractMemoryFile (sentry, &written);
|
||
delete mixup;
|
||
if (ex || written > 0)
|
||
rc += testfailed ("ExtractMemoryFile()", sentry);
|
||
|
||
mixup = new EyeContainer("test/mixup.ionu", badkey, ios::in);
|
||
ex = mixup->ExtractMemoryFile (sentry, &written);
|
||
delete mixup;
|
||
if (ex || written > 0)
|
||
rc += testfailed ("ExtractMemoryFile() ios::in", sentry);
|
||
|
||
if (rc == 0)
|
||
printf ("\nMixed up key tests passed\n-------------------------------\n");
|
||
else
|
||
printf ("\n%d Mixed up key tests failed\n-------------------------------\n", rc);
|
||
*/
|
||
return rc;
|
||
}
|
||
|
||
int TestEyeContainer()
|
||
{
|
||
int rc = 0;
|
||
/*
|
||
struct stat stat_buf;
|
||
char* coldmeta = NULL;
|
||
char* cmeta = NULL;
|
||
char* cmsg = NULL;
|
||
std::string txtmsg;
|
||
std::string msg;
|
||
EyeBytes currency (utf8, 6);
|
||
EyeBytes utfmsg;
|
||
EyeContainer* IOnU = NULL;
|
||
const std::string tags = "{\"title\":\"Encrypted World\",\"description\":\"The world is now encrypted\"}";
|
||
const std::string tags1 = "{\"title\":\"Parade of Fans\",\"description\":\"NEWARK - The guest list and the parade of limousines...\"}";
|
||
const std::string tags2 = "{\"title\":\"D-Link Patches Router\",\"description\":\"D-Link has taken action over three serious...\"}";
|
||
std::string realsig = sequencelogic::GenerateTGISig (TopicPerms);
|
||
unsigned char tgi64[64];
|
||
memcpy (tgi64, TGIkey, 32);
|
||
memset (tgi64+32, 85, 32);
|
||
Key tkey (realsig.c_str(), "key", 64, tgi64, Key::TGI);
|
||
Key mkey (realsig.c_str(), "key", 32, tgi64+32, Key::AES);
|
||
//SSL_load_error_strings(); /* readable error messages * /
|
||
//SSL_library_init(); /* initialize library * /
|
||
|
||
// Test the C++ interfaces
|
||
|
||
printf ("\nTestin C++ interfaces\n-------------------------------\n");
|
||
|
||
IOnU = new EyeContainer("test/nocontent.ionu", TGIkey, URN, TopicPerms);
|
||
IOnU->Finalize();
|
||
delete IOnU;
|
||
cout << EyeContainer::GetMetaData ("test/nocontent.ionu", IONU_EYE_META_FILE, mkey) << endl;
|
||
cout << EyeContainer::GetMetaData ("test/nocontent.ionu", IONU_EYE_PERM_FILE, mkey) << endl;
|
||
cout << EyeContainer::GetContentMetaData ("test/nocontent.ionu", ".imchat", mkey) << endl;
|
||
cout << EyeContainer::GetContentMetaData ("test/nocontent.ionu", "", mkey) << endl;
|
||
|
||
IOnU = new EyeContainer("test/test.ionu", TGIkey, URN, TopicPerms);
|
||
IOnU->AddContent ("test/Screen Shot 2013-04-18 at 1.14.42 PM.png", "image/png");
|
||
IOnU->Finalize();
|
||
delete IOnU;
|
||
IOnU = new EyeContainer("test/test.ionu", TGIkey);
|
||
if (!IOnU->ExtractFile ("Screen Shot 2013-04-18 at 1.14.42 PM.png"))
|
||
rc += testfailed ("ExtractFile", "Screen Shot 2013-04-18 at 1.14.42 PM.png");
|
||
if (!filecompare ("test/Screen Shot 2013-04-18 at 1.14.42 PM.png", "Screen Shot 2013-04-18 at 1.14.42 PM.png"))
|
||
rc += testfailed ("File compare", "Screen Shot 2013-04-18 at 1.14.42 PM.png");
|
||
delete IOnU;
|
||
sequencelogic::RemoveFile ("Screen Shot 2013-04-18 at 1.14.42 PM.png");
|
||
|
||
IOnU = new EyeContainer("test/test.ionu", TGIkey, URN, TopicPerms);
|
||
IOnU->AddContent ("test/Disruptor-1.0.pdf", "application/pdf");
|
||
IOnU->Finalize();
|
||
delete IOnU;
|
||
IOnU = new EyeContainer("test/test.ionu", TGIkey);
|
||
if (!IOnU->ExtractFile ("Disruptor-1.0.pdf"))
|
||
rc += testfailed ("ExtractFile", "Disruptor-1.0.pdf");
|
||
if (!filecompare ("test/Disruptor-1.0.pdf", "Disruptor-1.0.pdf"))
|
||
rc += testfailed ("File compare", "Disruptor-1.0.pdf");
|
||
delete IOnU;
|
||
sequencelogic::RemoveFile ("Disruptor-1.0.pdf");
|
||
|
||
IOnU = new EyeContainer("test/test.ionu", TGIkey, URN, TopicPerms);
|
||
IOnU->AddContent ("test/photo.jpg", "image/jpeg");
|
||
IOnU->Finalize();
|
||
delete IOnU;
|
||
IOnU = new EyeContainer("test/test.ionu", TGIkey);
|
||
if (!IOnU->ExtractFile ("photo.jpg"))
|
||
rc += testfailed ("ExtractFile", "photo.jpg");
|
||
if (!filecompare ("test/photo.jpg", "photo.jpg"))
|
||
rc += testfailed ("File compare", "photo.jpg");
|
||
delete IOnU;
|
||
sequencelogic::RemoveFile ("photo.jpg");
|
||
|
||
IOnU = new EyeContainer("test/test.ionu", TGIkey, URN, TopicPerms);
|
||
IOnU->AddContent ("test/Nikki-Temp.jpg", "image/jpeg");
|
||
IOnU->Finalize();
|
||
delete IOnU;
|
||
IOnU = new EyeContainer("test/test.ionu", TGIkey);
|
||
if (!IOnU->ExtractFile ("Nikki-Temp.jpg"))
|
||
rc += testfailed ("ExtractFile", "Nikki-Temp.jpg");
|
||
if (!filecompare ("test/Nikki-Temp.jpg", "Nikki-Temp.jpg"))
|
||
rc += testfailed ("File compare", "Nikki-Temp.jpg");
|
||
delete IOnU;
|
||
sequencelogic::RemoveFile ("Nikki-Temp.jpg");
|
||
|
||
IOnU = new EyeContainer("test/test.ionu", TGIkey, URN, TopicPerms);
|
||
IOnU->AddContent ("test/End User License Agreement.rtf", "text/rtf");
|
||
IOnU->Finalize();
|
||
delete IOnU;
|
||
IOnU = new EyeContainer("test/test.ionu", TGIkey);
|
||
if (!IOnU->ExtractFile ("End User License Agreement.rtf"))
|
||
rc += testfailed ("ExtractFile", "End User License Agreement.rtf");
|
||
if (!filecompare ("test/End User License Agreement.rtf", "End User License Agreement.rtf"))
|
||
rc += testfailed ("File compare", "End User License Agreement.rtf");
|
||
delete IOnU;
|
||
sequencelogic::RemoveFile ("End User License Agreement.rtf");
|
||
|
||
IOnU = new EyeContainer("test/test.ionu", TGIkey, URN, TopicPerms);
|
||
IOnU->AddContent ("test/TestWordDoc2.docx", "application/vnd.ms-word");
|
||
IOnU->Finalize();
|
||
delete IOnU;
|
||
IOnU = new EyeContainer("test/test.ionu", TGIkey);
|
||
if (!IOnU->ExtractFile ("TestWordDoc2.docx"))
|
||
rc += testfailed ("ExtractFile", "TestWordDoc2.docx");
|
||
if (!filecompare ("test/TestWordDoc2.docx", "TestWordDoc2.docx"))
|
||
rc += testfailed ("File compare", "TestWordDoc2.docx");
|
||
delete IOnU;
|
||
sequencelogic::RemoveFile ("TestWordDoc2.docx");
|
||
|
||
IOnU = new EyeContainer("test/test.ionu", tkey, URN, TopicPerms);
|
||
IOnU->AddTextMessage (".imchat", "A long and verbose yo there to you from me type chat message to test various stuff with");
|
||
IOnU->AddTags (tags);
|
||
IOnU->AddContent(testfile, "test/plaintext");
|
||
cout << "LastModifiedTimeOfEntry() " << IOnU->LastModifiedTimeOfEntry (".imchat") << endl;
|
||
cout << "MIMETypeOfEntry() " << IOnU->MIMETypeOfEntry (".imchat") << endl;
|
||
cout << "SizeOfEntry(.imchat) " << IOnU->SizeOfEntry (".imchat") << endl;
|
||
cout << "SizeOfEntry(tartest.txt) " << IOnU->SizeOfEntry ("tartest.txt") << endl;
|
||
cout << "SizeOfEntry(bad) " << IOnU->SizeOfEntry ("bad") << endl;
|
||
IOnU->Finalize();
|
||
delete IOnU;
|
||
|
||
// Corrupt .ionu files
|
||
ifstream ifile ("test/test.ionu", ios::in | ios::binary | ios::ate);
|
||
if (ifile.is_open())
|
||
{
|
||
size_t bytes = (size_t)ifile.tellg();
|
||
ifile.seekg (0, ios::beg);
|
||
char* big = new char[bytes];
|
||
ifile.read (big, bytes);
|
||
ifile.close();
|
||
for (size_t i = 0; i < bytes; i += 179) {
|
||
char pb = big[i];
|
||
ofstream rfile ("rand.ionu", ios::out | ios::binary | ios::trunc);
|
||
big[i] = 85;
|
||
rfile.write (big, bytes);
|
||
rfile.close();
|
||
//EyeContainer::GetStatus ("rand.ionu");
|
||
big[i] = pb;
|
||
IOnU = new EyeContainer("rand.ionu", TGIkey);
|
||
//txtmsg = IOnU->GetMetaData ();
|
||
txtmsg = IOnU->GetTextMessage (".imchat");
|
||
if (txtmsg.size() > 0)
|
||
rc += testfailed ("Corruption", txtmsg);
|
||
delete IOnU;
|
||
}
|
||
delete[] big;
|
||
}
|
||
|
||
if (rc == 0) printf ("Corruption tests passed\n");
|
||
|
||
cout << EyeContainer::GetMetaData ("test/test.ionu", IONU_EYE_META_FILE, mkey) << endl;
|
||
cout << EyeContainer::GetContentMetaData ("test/test.ionu", ".imchat", mkey) << endl;
|
||
cout << EyeContainer::GetContentMetaData ("test/test.ionu", "", mkey) << endl;
|
||
IOnU = new EyeContainer("test/test.ionu", tkey);
|
||
cout << IOnU->GetMetaData() << endl;
|
||
cout << IOnU->GetPermissions() << endl;
|
||
txtmsg = IOnU->GetTextMessage (".imchat");
|
||
if (txtmsg.size() > 0)
|
||
cout << "<" << txtmsg << ">" << endl;
|
||
else
|
||
rc += testfailed ("Can't find", ".imchat");
|
||
cout << IOnU->GetContentFileObjects() << endl;
|
||
cout << IOnU->GetContentFilenames() << endl;
|
||
IOnU->ListFiles();
|
||
std::string gtags = IOnU->GetTags();
|
||
if (gtags == tags)
|
||
cout << "Tags: " << gtags << endl;
|
||
else
|
||
rc += testfailed ("Can't find tags", gtags);
|
||
IOnU->ShredContents (shredurn);
|
||
delete IOnU;
|
||
std::string shredded = EyeContainer::GetMetaData ("test/test.ionu", IONU_EYE_META_FILE, mkey);
|
||
if (shredded.find ("deleted") == string::npos)
|
||
rc += testfailed ("ShredContents status not set to deleted - static", "test/test.ionu");
|
||
cout << shredded << endl;
|
||
IOnU = new EyeContainer("test/test.ionu", tkey);
|
||
shredded = IOnU->GetContentFilenames();
|
||
if (shredded.compare ("[]") != 0)
|
||
rc += testfailed ("ShredContents content array not empty", "test/test.ionu");
|
||
shredded = IOnU->GetMetaData();
|
||
if (shredded.find ("deleted") == string::npos)
|
||
rc += testfailed ("ShredContents status not set to deleted", "test/test.ionu");
|
||
shredded = IOnU->GetPermissions();
|
||
if (shredded.compare (TopicPerms) != 0)
|
||
rc += testfailed ("ShredContents perms messed up", "test/test.ionu");
|
||
|
||
IOnU->ShredContents (shredurn);
|
||
delete IOnU;
|
||
|
||
IOnU = new EyeContainer("test/test.ionu", TGIkey, URN, PERMS);
|
||
IOnU->AddTextMessage (".imchat", "Hi");
|
||
|
||
Key bkey ("Meta", "key", SL_AES_KEY_LEN, badkey, Key::AES);
|
||
Key gkey;
|
||
Key rkey ("Meta", "RSA", (int)strlen(RSA_private), (const unsigned char*)RSA_private, Key::RSA);
|
||
IOnU->AddMetaData (".ionuhistory", "This is the history", mkey);
|
||
IOnU->AddMetaData (".ionutags", "history,middle,kingdom", gkey);
|
||
IOnU->AddMetaData (".private", "RSA encrypted private data", rkey);
|
||
IOnU->AddTextMessage (".imchat", "Hi");
|
||
size_t siglen = 0;
|
||
unsigned char* sig = rkey.PrivateKeySign ((unsigned char*)"Hi", 2, &siglen);
|
||
std::string signature ((char*)sig, siglen);
|
||
IOnU->AddMetaData (".signature", signature, gkey);
|
||
delete[] sig;
|
||
std::cout << IOnU->GetMetaData (".ionuhistory", mkey) << std::endl;
|
||
std::cout << IOnU->GetMetaData (".ionuhistory", bkey) << std::endl;
|
||
std::cout << IOnU->GetMetaData (".ionutags", gkey) << std::endl;
|
||
std::cout << IOnU->GetMetaData (".private", rkey) << std::endl;
|
||
signature = IOnU->GetMetaData (".signature", gkey);
|
||
std::cout << rkey.PublicKeyVerify ((unsigned char*)signature.data(), signature.size(), (unsigned char*)"Hi", 2) << std::endl;
|
||
delete IOnU;
|
||
|
||
//exit (1);
|
||
IOnU = new EyeContainer("test/test.ionu", TGIkey, URN, PERMS);
|
||
IOnU->AddTextMessage (".imchat", "Hi there from someone who is not who you think");
|
||
//IOnU->AddContent ("test/test.jpeg", NULL);
|
||
IOnU->Finalize();
|
||
std::string metadata = IOnU->GetMetaData();
|
||
std::string spoof = metadata;
|
||
size_t pos = spoof.find ("FFFFFFFFFFFF");
|
||
spoof.replace (pos, 12, "FFFFFFFFFFF7");
|
||
cout << spoof << endl;
|
||
IOnU->ReplaceMetaData (spoof.c_str());
|
||
IOnU->Finalize();
|
||
delete IOnU;
|
||
IOnU = new EyeContainer("test/test.ionu", TGIkey);
|
||
txtmsg = IOnU->GetTextMessage (".imchat");
|
||
if (txtmsg.size() > 0)
|
||
rc += testfailed ("Spoof", txtmsg);
|
||
if (IOnU->ReplaceMetaData (tgiMeta))
|
||
rc += testfailed ("ReplaceMetaData()", "mismatching tgi keys");
|
||
delete IOnU;
|
||
|
||
IOnU = new EyeContainer("test/test.ionu", TGIkey, URN, PERMS);
|
||
IOnU->AddContent(testfile, "test/plain");
|
||
IOnU->Finalize();
|
||
metadata = IOnU->GetMetaData();
|
||
if (metadata.size() > 0)
|
||
cout << metadata << endl;
|
||
else
|
||
rc += testfailed ("GetMetaData", testfile);
|
||
delete IOnU;
|
||
|
||
IOnU = new EyeContainer ("test/test.ionu", TGIkey);
|
||
if (IOnU->ExtractFile (testfile) && filecompare (testfile, testfile_orig))
|
||
printf ("Extracted tartest.txt\n");
|
||
else
|
||
rc += testfailed ("Extract", testfile);
|
||
delete IOnU;
|
||
|
||
//IOnU = new EyeContainer("test/7E303527-9996-462C-BAAC-D39BADCA377E.ionu", TGIkey);
|
||
|
||
IOnU = new EyeContainer("test/test.ionu", TGIkey);
|
||
IOnU->ListFiles();
|
||
metadata = IOnU->GetMetaData();
|
||
if (metadata.size() > 0)
|
||
cout << metadata << endl;
|
||
else
|
||
rc += testfailed ("GetMetaData", testfile);
|
||
|
||
EyeContainer* merge = new EyeContainer ("test/test.ionu", TGIkey, URN, PERMS);
|
||
merge->AddContent (testfile, "test/plain");
|
||
merge->AddTextMessage ("Merger", "mergers and acquisitions are my specialty");
|
||
IOnU->MergeContent (merge);
|
||
delete merge;
|
||
|
||
IOnU->AddTextMessage ("Thread", "Hello, is anyone out there?");
|
||
IOnU->AddTextMessage ("Currency Symbols", currency, "text/plain;charset=utf-8");
|
||
IOnU->AddTextMessage ("Last", "The last word");
|
||
|
||
bool found = IOnU->GetTextMessage ("Thread", utfmsg);
|
||
if (found)
|
||
printf ("%s\n", utfmsg.GetString());
|
||
else
|
||
rc += testfailed ("GetTextMessage", "Thread");
|
||
found = IOnU->GetTextMessage ("Merger", utfmsg);
|
||
if (found)
|
||
printf ("%s\n", utfmsg.GetString());
|
||
else
|
||
rc += testfailed ("GetTextMessage", "Merger");
|
||
utfmsg.Assign ("UTF-8 encoded string");
|
||
IOnU->AddTextMessage ("Thread", "Nobody here but us chickens");
|
||
IOnU->AddTextMessage ("UTFThread", utfmsg, "text/plain;charset=utf-8");
|
||
found = IOnU->GetTextMessage ("Thread", utfmsg);
|
||
if (found)
|
||
printf ("%s\n", utfmsg.GetString());
|
||
else
|
||
rc += testfailed ("GetTextMessage", "Chicken Thread");
|
||
IOnU->Finalize();
|
||
delete IOnU;
|
||
|
||
if (rc == 0) printf ("so far passed\n");
|
||
IOnU = new EyeContainer("test/test.ionu", TGIkey);
|
||
IOnU->ListFiles();
|
||
metadata = IOnU->GetMetaData();
|
||
if (metadata.size() > 0)
|
||
cout << metadata << endl;
|
||
else
|
||
rc += testfailed ("GetMetaData", testfile);
|
||
IOnU->UpdateMetaData (updateMeta);
|
||
metadata = IOnU->GetMetaData();
|
||
if (metadata.size() > 0)
|
||
cout << metadata << endl;
|
||
else
|
||
rc += testfailed ("UpdateMetaData", testfile);
|
||
found = IOnU->GetTextMessage ("Thread", utfmsg);
|
||
if (found)
|
||
printf ("%s\n", utfmsg.GetString());
|
||
else
|
||
rc += testfailed ("GetTextMessage", "Thread");
|
||
found = IOnU->GetTextMessage ("UTFThread", utfmsg);
|
||
if (found)
|
||
printf ("%s\n", utfmsg.GetString());
|
||
else
|
||
rc += testfailed ("GetTextMessage", "UTFThread");
|
||
found = IOnU->GetTextMessage ("Currency Symbols", utfmsg);
|
||
if (!found || !currency.Equals (utfmsg))
|
||
rc += testfailed ("GetTextMessage", "Currency");
|
||
|
||
// Change the TGI key and try both old and new TGI keys
|
||
Key bbkey ("Bad", "key", SL_AES_KEY_LEN, badkey, Key::TGI);
|
||
Key ggkey ("Good", "key", SL_AES_KEY_LEN, TGIkey, Key::TGI);
|
||
IOnU->ReKey (bbkey);
|
||
msg = IOnU->GetTextMessage ("Thread");
|
||
if (msg.compare ("Nobody here but us chickens") != 0)
|
||
rc += testfailed ("ReKey - memory", testfile);
|
||
IOnU->Finalize();
|
||
delete IOnU;
|
||
IOnU = new EyeContainer("test/test.ionu", TGIkey);
|
||
txtmsg = IOnU->GetTextMessage ("Thread");
|
||
if (txtmsg.size() > 1 && txtmsg[0] == 'N' && txtmsg[1] == 'o')
|
||
rc += testfailed ("ReKey - old key", txtmsg);
|
||
delete IOnU;
|
||
IOnU = new EyeContainer("test/test.ionu", badkey);
|
||
msg = IOnU->GetTextMessage ("Thread");
|
||
if (msg.compare ("Nobody here but us chickens") != 0)
|
||
rc += testfailed ("ReKey - new key", testfile);
|
||
std::string oldmeta = IOnU->GetMetaData();
|
||
|
||
// Rekey and update permissions, which should change TGIsig in meta
|
||
IOnU->ReKey (ggkey, PERMS2);
|
||
metadata = IOnU->GetMetaData();
|
||
if (metadata.compare (oldmeta) == 0)
|
||
rc += testfailed ("ReKey - new perms, TGIsig", testfile);
|
||
msg = IOnU->GetTextMessage ("Thread");
|
||
if (msg.compare ("Nobody here but us chickens") != 0)
|
||
rc += testfailed ("ReKey - new key and perms", testfile);
|
||
IOnU->Finalize();
|
||
delete IOnU;
|
||
metadata = EyeContainer::GetPermissionsClassic ("test/test.ionu");
|
||
if (metadata.compare (PERMS2) != 0 )
|
||
rc += testfailed ("ReKey", PERMS2);
|
||
if (rc == 0)
|
||
printf ("Rekey tests passed\n");
|
||
if (!IOnU->Shred ("test/test.ionu"))
|
||
rc += testfailed ("Shred", testfile);
|
||
|
||
if (rc == 0) printf ("so far passed\n");
|
||
if (stat("test/test.ionu", &stat_buf) != 0)
|
||
printf ("Shred passed\n");
|
||
else
|
||
rc += testfailed ("Shred", testfile);
|
||
|
||
// Message with attachments and thumbnail
|
||
IOnU = new EyeContainer("test/test.ionu", TGIkey, URN, PERMS);
|
||
IOnU->AddTextMessage ("Message", "See attached coding guidlines, html, and xml");
|
||
if (!IOnU->AddContent (attachfile, ""))
|
||
rc += testfailed ("AddContent", attachfile);
|
||
if (!IOnU->AddContent (htmlfile, "text/html;charset=utf-8"))
|
||
rc += testfailed ("AddContent", htmlfile);
|
||
if (!IOnU->AddMetaData (".ionuhistory", operationsMeta))
|
||
rc += testfailed ("AddContent", ".ionuhistory");
|
||
if (!IOnU->AddContent ("style.xsd", xmlfile, ""))
|
||
rc += testfailed ("AddContent", "style.xsd");
|
||
if (!IOnU->AddContent (xmlfile, ""))
|
||
rc += testfailed ("AddContent", xmlfile);
|
||
if (!IOnU->AddContent (jsonfile, "application/json"))
|
||
rc += testfailed ("AddContent", jsonfile);
|
||
if (IOnU->AddContent (njsonfile, "")) // This file does not exist
|
||
rc += testfailed ("AddContent", njsonfile);
|
||
if (!IOnU->AddThumbnail (thumbfile, ""))
|
||
rc += testfailed ("AddThumbnail", thumbfile);
|
||
IOnU->Finalize();
|
||
delete IOnU;
|
||
|
||
IOnU = new EyeContainer("test/test.ionu", TGIkey);
|
||
if (!IOnU->HasContent (xmlfile))
|
||
rc += testfailed ("HasContent", xmlfile);
|
||
|
||
IOnU->ListFiles();
|
||
std::string cf = IOnU->GetContentFilenames();
|
||
if (cf.size() > 4)
|
||
cout << cf << endl;
|
||
else
|
||
rc += testfailed ("GetContentFilenames", testfile);
|
||
cf = IOnU->GetContentFileObjects();
|
||
if (cf.size() > 4)
|
||
cout << cf << endl;
|
||
else
|
||
rc += testfailed ("GetContentFileObjects", testfile);
|
||
metadata = IOnU->GetMetaData();
|
||
if (metadata.size() > 0)
|
||
cout << metadata << endl;
|
||
else
|
||
rc += testfailed ("GetMetaData", testfile);
|
||
txtmsg = IOnU->GetTextMessage ("Message");
|
||
if (txtmsg.size() > 0)
|
||
cout << txtmsg << endl;
|
||
else
|
||
rc += testfailed ("GetTextMessage", "Message");
|
||
metadata = IOnU->GetPermissions();
|
||
if (metadata.size() > 0)
|
||
cout << metadata << endl;
|
||
else
|
||
rc += testfailed ("GetPermissions", testfile);
|
||
IOnU->UpdatePermissions ("{\"read\":[\"me\",\"you\"],\"write\":[\"me\",\"you\"]}");
|
||
metadata = IOnU->GetPermissions();
|
||
if (metadata.size() > 0)
|
||
cout << metadata << endl;
|
||
else
|
||
rc += testfailed ("GetPermissions", testfile);
|
||
IOnU->UpdatePermissions ("{\"read\":[\"me\"]}");
|
||
metadata = IOnU->GetPermissions();
|
||
if (metadata.size() > 0)
|
||
cout << metadata << endl;
|
||
else
|
||
rc += testfailed ("GetPermissions", testfile);
|
||
IOnU->UpdatePermissions ("{\"read\":[\"+george\"], \"write\":[\"+george\"]}");
|
||
metadata = IOnU->GetPermissions();
|
||
if (metadata.size() > 0)
|
||
cout << metadata << endl;
|
||
else
|
||
rc += testfailed ("GetPermissions", testfile);
|
||
IOnU->UpdatePermissions ("{\"read\":[\"-george\"]}");
|
||
metadata = IOnU->GetPermissions();
|
||
if (metadata.size() > 0)
|
||
cout << metadata << endl;
|
||
else
|
||
rc += testfailed ("GetPermissions", testfile);
|
||
|
||
IOnU->UpdateMetaData ("{\"msg\":{\"drr\":true}}");
|
||
metadata = IOnU->GetMetaData();
|
||
if (metadata.size() > 0)
|
||
cout << metadata << endl;
|
||
else
|
||
rc += testfailed ("UpdateMetaData", testfile);
|
||
|
||
// Get HTML file contents as a message
|
||
txtmsg = IOnU->GetTextMessage ("test.html");
|
||
if (txtmsg.size() > 1 && txtmsg.compare (0, 14, "<!DOCTYPE html>", 14) == 0)
|
||
printf ("HTML message passed\n");
|
||
else
|
||
rc += testfailed ("GetTextMessage", "<!DOCTYPE html>");
|
||
|
||
if (!IOnU->RemoveEntry (xmlfile))
|
||
rc += testfailed ("RemoveEntry", xmlfile);
|
||
IOnU->Finalize();
|
||
delete IOnU;
|
||
IOnU = new EyeContainer("test/test.ionu", TGIkey);
|
||
IOnU->ListFiles();
|
||
metadata = IOnU->GetMetaData();
|
||
if (metadata.size() > 0)
|
||
cout << metadata << endl;
|
||
if (!IOnU->ExtractFile ("style.xsd", "test/extracted.xsd"))
|
||
rc += testfailed ("ExtractFile", "style.xsd");
|
||
delete IOnU;
|
||
|
||
// Create a large archive
|
||
IOnU = new EyeContainer("test/bigtest.ionu", TGIkey, URN, PERMS);
|
||
IOnU->AddTextMessage ("test/Message", "Holy crap Batman there are a lot of files in here, and there are no problems with that");
|
||
char message[64];
|
||
//for (int i = 0; i < 1000; ++i) { // Verified with 1,000, but just use 10 for regular test runs
|
||
for (int i = 0; i < 10; ++i) {
|
||
sprintf (message, "test/Message%d", i);
|
||
IOnU->AddTextMessage (message, "I'm a robot and I love to chat with other bots");
|
||
}
|
||
if (!IOnU->RenameFile ("test/Message4", "test/renamed"))
|
||
rc += testfailed ("RenameFile()", "r/o");
|
||
IOnU->Finalize();
|
||
delete IOnU;
|
||
|
||
IOnU = new EyeContainer("test/tags1.ionu", TGIkey, URN, TopicPerms);
|
||
IOnU->AddTextMessage (".imchat", "A long and verbose yo there to you from me type chat message to test various stuff with");
|
||
IOnU->AddTags (tags1);
|
||
IOnU->Finalize();
|
||
delete IOnU;
|
||
IOnU = new EyeContainer("test/tags2.ionu", TGIkey, URN, TopicPerms);
|
||
IOnU->AddTextMessage (".imchat", "A long and verbose yo there to you from me type chat message to test various stuff with");
|
||
IOnU->AddTags (tags2);
|
||
IOnU->Finalize();
|
||
delete IOnU;
|
||
|
||
IOnU = new EyeContainer("test/tags1.ionu", TGIkey, ios::in);
|
||
gtags = IOnU->GetTags();
|
||
cout << gtags << endl;
|
||
delete IOnU;
|
||
IOnU = new EyeContainer("test/tags2.ionu", TGIkey, ios::in);
|
||
gtags = IOnU->GetTags();
|
||
cout << gtags << endl;
|
||
delete IOnU;
|
||
|
||
if (rc == 0) printf ("so far passed\n");
|
||
// Test readonly EyeContainer
|
||
printf ("Readonly tests ----------------\n");
|
||
size_t nwritten = 0;
|
||
std::string sb;
|
||
std::string sentry ("test/Message");
|
||
std::streamoff spos = 0;
|
||
std::streamoff ssize = 0;
|
||
char sbuffer[1024];
|
||
IOnU = new EyeContainer("test/bigtest.ionu", ggkey, ios::in);
|
||
IOnU->ListFiles();
|
||
IOnU->ExtractFiles();
|
||
metadata = IOnU->GetMetaData();
|
||
if (metadata.size() < 50)
|
||
rc += testfailed ("GetMetaData", "r/o");
|
||
cout << metadata << endl;
|
||
metadata = IOnU->GetPermissions();
|
||
if (metadata.size() < 50)
|
||
rc += testfailed ("GetPermissions", "r/o");
|
||
metadata = IOnU->GetMetaData(".ionumeta");
|
||
if (metadata.size() < 50)
|
||
rc += testfailed ("GetMetaData(.ionumeta)", "r/o");
|
||
metadata = IOnU->GetMetaData(".ionuperm");
|
||
if (metadata.size() < 50)
|
||
rc += testfailed ("GetMetaData(.ionuperm)", "r/o");
|
||
metadata = IOnU->GetContentFilenames();
|
||
if (metadata.size() < 50)
|
||
rc += testfailed ("GetContentFilenames()", "r/o");
|
||
metadata = IOnU->GetContentFileObjects();
|
||
if (metadata.size() < 50)
|
||
rc += testfailed ("GetContentFileObjects()", "r/o");
|
||
if (!IOnU->HasEntry (sentry, &ssize))
|
||
rc += testfailed ("GetContentMetaData()", "r/o");
|
||
else
|
||
cout << "found " << sentry << " " << ssize << endl;
|
||
|
||
if (IOnU->GetFileSize ("test/Message3") != 46)
|
||
rc += testfailed ("GetFileSize()", "r/o");
|
||
metadata = IOnU->GetTextMessage (sentry);
|
||
if (metadata.compare (0, 9, "Holy crap", 9) != 0)
|
||
rc += testfailed ("GetTextMessage()", "r/o");
|
||
if (!IOnU->ExtractFile (sentry, sentry))
|
||
rc += testfailed ("ExtractFile()", "r/o");
|
||
|
||
spos = 0;
|
||
IOnU->ReadStream (sentry, spos, sbuffer, 35, &nwritten);
|
||
sb.assign (sbuffer, nwritten);
|
||
cout << sb << endl;
|
||
spos += nwritten;
|
||
IOnU->ReadStream (sentry, spos, sbuffer, 32, &nwritten);
|
||
sb.assign (sbuffer, nwritten);
|
||
cout << sb << endl;
|
||
spos += nwritten;
|
||
IOnU->ReadStream (sentry, spos, sbuffer, 32, &nwritten);
|
||
sb.assign (sbuffer, nwritten);
|
||
cout << sb << endl;
|
||
spos = 7;
|
||
IOnU->ReadStream (sentry, spos, sbuffer, 32, &nwritten);
|
||
sb.assign (sbuffer, nwritten);
|
||
cout << sb << endl;
|
||
if (metadata.compare (0, 9, "Holy crap", 9) != 0)
|
||
rc += testfailed ("GetTextMessage()", "r/o");
|
||
delete IOnU;
|
||
//exit(1);
|
||
|
||
// Test EyeContainer stream interfaces
|
||
if (rc == 0) printf ("so far passed\n");
|
||
printf ("Stream interface tests ----------------\n");
|
||
sentry = "stream";
|
||
IOnU = new EyeContainer("test/streamtest.ionu", TGIkey, URN, PERMS);
|
||
spos = 0;
|
||
IOnU->WriteStream (sentry, spos, "This is a streaming video test s", 32, &nwritten);
|
||
spos = 32;
|
||
IOnU->WriteStream (sentry, spos, "tream not really", 16, &nwritten);
|
||
IOnU->Finalize();
|
||
delete IOnU;
|
||
IOnU = new EyeContainer("test/streamtest.ionu", TGIkey);
|
||
unsigned char* ex = IOnU->ExtractMemoryFile (sentry, &nwritten);
|
||
if (ex) {
|
||
sb.assign ((char*)ex, nwritten);
|
||
cout << sb << endl;
|
||
delete[] ex;
|
||
}
|
||
else
|
||
rc += testfailed ("ExtractMemoryFile()", sentry);
|
||
spos = 0;
|
||
IOnU->ReadStream (sentry, spos, sbuffer, 48, &nwritten);
|
||
sb.assign (sbuffer, 48);
|
||
cout << sb << endl;
|
||
spos = 32;
|
||
IOnU->WriteStream (sentry, spos, "tream yes it is!", 16, &nwritten);
|
||
IOnU->Finalize();
|
||
delete IOnU;
|
||
IOnU = new EyeContainer("test/streamtest.ionu", TGIkey);
|
||
IOnU->ListFiles();
|
||
metadata = IOnU->GetMetaData();
|
||
cout << metadata << endl;
|
||
spos = 0;
|
||
IOnU->ReadStream (sentry, spos, sbuffer, 48, &nwritten);
|
||
sb.assign (sbuffer, 48);
|
||
cout << sb << endl;
|
||
spos = 30;
|
||
IOnU->SetStreamSize (sentry, spos);
|
||
cout << "streamsize " << IOnU->GetStreamSize(sentry) << endl;
|
||
IOnU->Finalize();
|
||
delete IOnU;
|
||
IOnU = new EyeContainer("test/streamtest.ionu", ggkey, ios::in);
|
||
IOnU->ListFiles();
|
||
IOnU->ExtractFiles();
|
||
metadata = IOnU->GetMetaData();
|
||
cout << metadata << endl;
|
||
delete IOnU;
|
||
IOnU = new EyeContainer("test/streamtest.ionu", TGIkey);
|
||
cout << "streamsize " << IOnU->GetStreamSize(sentry) << endl;
|
||
spos = 0;
|
||
IOnU->SetStreamSize (sentry, spos);
|
||
cout << "streamsize " << IOnU->GetStreamSize(sentry) << endl;
|
||
IOnU->WriteStream (sentry, spos, (void*)"First chunk of data for stream", 30, &nwritten);
|
||
spos = 30;
|
||
IOnU->WriteStream (sentry, spos, (void*)", second chunk of data for stream", 33, &nwritten);
|
||
spos = 63;
|
||
IOnU->WriteStream (sentry, spos, (void*)", last chunk of data for stream", 31, &nwritten);
|
||
IOnU->Finalize();
|
||
delete IOnU;
|
||
IOnU = new EyeContainer("test/streamtest.ionu", TGIkey);
|
||
cout << "streamsize " << IOnU->GetStreamSize(sentry) << endl;
|
||
spos = 0;
|
||
IOnU->ReadStream (sentry, spos, sbuffer, 94, &nwritten);
|
||
sb.assign (sbuffer, 94);
|
||
cout << sb << endl;
|
||
cout << IOnU->GetMetaData() << endl;
|
||
ex = IOnU->ExtractMemoryFile (sentry, &nwritten);
|
||
if (nwritten != 94 || sequencelogic::MemCmp (sb.data(), ex, nwritten) != 0)
|
||
rc += testfailed ("ExtractMemoryFile", "stream 94");
|
||
if (ex) delete[] ex;
|
||
delete IOnU;
|
||
IOnU = new EyeContainer("test/streamtest.ionu", TGIkey);
|
||
cout << "streamsize " << IOnU->GetStreamSize(sentry) << endl;
|
||
spos = 40;
|
||
IOnU->SetStreamSize (sentry, spos);
|
||
IOnU->Finalize();
|
||
delete IOnU;
|
||
IOnU = new EyeContainer("test/streamtest.ionu", TGIkey);
|
||
ex = IOnU->ExtractMemoryFile (sentry, &nwritten);
|
||
if (nwritten != 40)
|
||
rc += testfailed ("ExtractMemoryFile", "stream 40");
|
||
if (ex) delete[] ex;
|
||
delete IOnU;
|
||
|
||
|
||
if (rc == 0)
|
||
printf ("\nC++ interface tests passed\n-------------------------------\n");
|
||
else
|
||
printf ("\n%d C++ interface tests failed\n-------------------------------\n", rc);
|
||
|
||
// Test the extern "C" interfaces
|
||
printf ("\nTestin C interfaces\n-------------------------------\n");
|
||
|
||
if (ionu_eyefile_is_valid (NULL))
|
||
rc += testfailed ("ionu_eye_is_valid", "NULL");
|
||
if (ionu_eyefile_is_valid ("bogus"))
|
||
rc += testfailed ("ionu_eye_is_valid", "bogus");
|
||
if (ionu_eyefile_is_valid (testfile))
|
||
rc += testfailed ("ionu_eye_is_valid", testfile);
|
||
if (! ionu_eyefile_create_with_content (cionu, TGIkey, "TGI", TGIkey, SL_AES_KEY_LEN, "application/tgi", URN, PERMS))
|
||
rc += testfailed ("ionu_eye_create_with_content", "TGI");
|
||
if (! ionu_eyefile_create_with_message (cionu, TGIkey, "Thread", "Hello there", 11, URN, PERMS))
|
||
rc += testfailed ("ionu_eye_create_with_message", "Thread");
|
||
if (! ionu_eyefile_is_valid (cionu))
|
||
rc += testfailed ("ionu_eye_is_valid", cionu);
|
||
|
||
// Simple message test
|
||
cmsg = ionu_eyefile_get_message (cionu, TGIkey, "Thread");
|
||
if (cmsg) {
|
||
printf ("%s\n", cmsg);
|
||
free (cmsg);
|
||
}
|
||
else
|
||
rc += testfailed ("ionu_eye_get_message", "Thread");
|
||
|
||
// File test with bad key, then good key
|
||
if (! ionu_eyefile_create_with_file (cionu, TGIkey, testfile, "test/plain", URN, PERMS))
|
||
rc += testfailed ("ionu_eye_create_with_file", cionu);
|
||
if (ionu_eyefile_extract_file (cionu, badkey, testfile)) {
|
||
if (filecompare (testfile, testfile_orig))
|
||
rc += testfailed ("Extract Bad TGI key", testfile);
|
||
else
|
||
printf ("PASSED: Bad TGI key test check\n");
|
||
}
|
||
else {
|
||
printf ("PASSED: Bad TGI key test\n");
|
||
}
|
||
|
||
if (ionu_eyefile_extract_file (cionu, TGIkey, testfile)) {
|
||
if (filecompare (testfile, testfile_orig))
|
||
printf ("PASSED: ionu_eyefile_extract_file: Good TGI key test\n");
|
||
else
|
||
rc += testfailed ("ionu_eyefile_extract_file: file differences", testfile);
|
||
}
|
||
else
|
||
rc += testfailed ("ionu_eyefile_extract_file: extract", testfile);
|
||
|
||
// Long path test
|
||
if (! ionu_eyefile_create_with_file (cionu, TGIkey, longtest, "test/plain", URN, PERMS))
|
||
rc += testfailed ("ionu_eye_create_with_file - longpath test", cionu);
|
||
if (ionu_eyefile_extract_file (cionu, TGIkey, longtest)) {
|
||
if (filecompare (longtest, testfile_orig))
|
||
printf ("PASSED: ionu_eyefile_extract_file: Long path test\n");
|
||
else
|
||
rc += testfailed ("ionu_eyefile_extract_file long path: file differences in long", testfile);
|
||
}
|
||
else
|
||
rc += testfailed ("ionu_eyefile_extract_file: extract long", testfile);
|
||
|
||
// Verify meta data
|
||
cmeta = ionu_eyefile_get_meta_data (cionu);
|
||
if (cmeta) {
|
||
printf ("%s\n", cmeta);
|
||
free (cmeta);
|
||
}
|
||
else
|
||
rc += testfailed ("ionu_eye_get_meta_data", cionu);
|
||
// Verify permissions data
|
||
cmeta = ionu_eyefile_get_perms (cionu);
|
||
if (cmeta) {
|
||
printf ("%s\n", cmeta);
|
||
free (cmeta);
|
||
}
|
||
else
|
||
rc += testfailed ("ionu_eye_get_permissions", cionu);
|
||
|
||
EyeLog::GetInstance()->SetLogLevel (EyeLog::IONU_DEBUG);
|
||
// Replace meta data, works first time, second fails because transaction count is too low
|
||
cmeta = ionu_eyefile_get_meta_data (cionu);
|
||
if (!ionu_eyefile_replace_meta_data (cionu, cmeta))
|
||
rc += testfailed ("ionu_eyefile_replace_meta_data - same meta", cionu);
|
||
if (ionu_eyefile_replace_meta_data (cionu, cmeta))
|
||
rc += testfailed ("ionu_eyefile_replace_meta_data - old meta", cionu);
|
||
free (cmeta);
|
||
|
||
// SHredd
|
||
if (ionu_eyefile_shred (cionu))
|
||
printf ("Shred passed\n");
|
||
else
|
||
rc += testfailed ("Shred failed", cionu);
|
||
|
||
// Message with multiple associated files and attachments
|
||
if (! ionu_eyefile_create_with_message (cionu, TGIkey, "Thread", "Hello there", 11, URN2, PERMS))
|
||
rc += testfailed ("ionu_eye_create_with_message", "Thread");
|
||
cmeta = ionu_eyefile_get_meta_data (cionu);
|
||
if (cmeta) {
|
||
printf ("%s\n", cmeta);
|
||
free (cmeta);
|
||
}
|
||
ionu_eyefile_add_file (cionu, TGIkey, attachfile, NULL);
|
||
ionu_eyefile_add_thumbnail (cionu, TGIkey, thumbfile, NULL);
|
||
ionu_eyefile_add_message (cionu, TGIkey, "Word", "see attachment", 14);
|
||
ionu_eyefile_add_content (cionu, TGIkey, "TGI", TGIkey, SL_AES_KEY_LEN, "application/tgi");
|
||
ionu_eyefile_add_message (cionu, TGIkey, "UTF", smiley, strlen(smiley)+1);
|
||
// Verify meta data
|
||
cmeta = ionu_eyefile_get_meta_data (cionu);
|
||
if (cmeta) {
|
||
printf ("%s\n", cmeta);
|
||
free (cmeta);
|
||
}
|
||
else
|
||
rc += testfailed ("ionu_eye_get_meta_data multiple files", cionu);
|
||
|
||
// Verify meta data
|
||
cmeta = ionu_eyefile_get_file_objects (cionu);
|
||
if (cmeta) {
|
||
printf ("%s\n", cmeta);
|
||
free (cmeta);
|
||
}
|
||
else
|
||
rc += testfailed ("ionu_eyefile_get_file_objects multiple files", cionu);
|
||
|
||
cmsg = ionu_eyefile_get_message (cionu, TGIkey, "Thread");
|
||
if (cmsg) {
|
||
printf ("%s\n", cmsg);
|
||
free (cmsg);
|
||
}
|
||
else
|
||
rc += testfailed ("ionu_eye_get_message", "Thread");
|
||
ionu_eyefile_add_message (cionu, TGIkey, "Word", "see attachment - replaced", 25);
|
||
cmsg = ionu_eyefile_get_message (cionu, TGIkey, "Word");
|
||
if (cmsg) {
|
||
printf ("%s\n", cmsg);
|
||
free (cmsg);
|
||
}
|
||
else
|
||
rc += testfailed ("ionu_eye_get_message", "Word");
|
||
|
||
cmsg = ionu_eyefile_get_message (cionu, TGIkey, "UTF");
|
||
if (cmsg) {
|
||
if (sequencelogic::StrCmp (cmsg, smiley) != 0)
|
||
rc += testfailed ("ionu_eye_get_message", smiley);
|
||
free (cmsg);
|
||
}
|
||
|
||
size_t thumbsize = ionu_eyefile_get_file_size (cionu, TGIkey, "thumb.png");
|
||
if (thumbsize != 45119) {
|
||
rc += testfailed ("ionu_eyefile_get_file_size", thumbfile);
|
||
}
|
||
|
||
if (ionu_eyefile_get_file_size (cionu, TGIkey, "TGI") != SL_AES_KEY_LEN)
|
||
rc += testfailed ("ionu_eyefile_get_file_size", "TGI");
|
||
unsigned char tbuff[SL_AES_KEY_LEN];
|
||
if (!ionu_eyefile_get_content (cionu, TGIkey, "TGI", tbuff))
|
||
rc += testfailed ("ionu_eyefile_get_content", "TGI");
|
||
if (memcmp (TGIkey, tbuff, SL_AES_KEY_LEN) != 0)
|
||
rc += testfailed ("ionu_eyefile_get_content", "TGI does not match");
|
||
|
||
if (ionu_eyefile_get_content_and_write_to_file (cionu, badkey, "Word", "test/word"))
|
||
rc += testfailed ("ionu_eyefile_get_content_and_write_to_file", "bad should fail");
|
||
if (!ionu_eyefile_get_content_and_write_to_file (cionu, TGIkey, "Word", "test/word"))
|
||
rc += testfailed ("ionu_eyefile_get_content_and_write_to_file", "didn't get the word");
|
||
if (!ionu_eyefile_get_content_and_write_to_file (cionu, TGIkey, "Word", "test/word"))
|
||
rc += testfailed ("ionu_eyefile_get_content_and_write_to_file", "didn't get the word twice");
|
||
if (ionu_eyefile_get_content_and_write_to_file (cionu, TGIkey, "Word", "test/readonly"))
|
||
rc += testfailed ("ionu_eyefile_get_content_and_write_to_file", "got the readonly word");
|
||
|
||
// Try to get a text message with badkey, should return NULL
|
||
cmsg = ionu_eyefile_get_message (cionu, badkey, "Word");
|
||
if (cmsg) {
|
||
rc += testfailed ("ionu_eye_get_message", "badkey Word");
|
||
free (cmsg);
|
||
}
|
||
// Change the key and try again
|
||
ionu_eyefile_change_key (cionu, TGIkey, badkey);
|
||
cmsg = ionu_eyefile_get_message (cionu, badkey, "Word");
|
||
if (cmsg) {
|
||
printf ("Rekeyed: %s\n", cmsg);
|
||
free (cmsg);
|
||
}
|
||
else
|
||
rc += testfailed ("ionu_eye_get_message", "rekeyed Word");
|
||
|
||
// Verify meta data
|
||
cmeta = ionu_eyefile_get_meta_data (cionu);
|
||
if (cmeta) {
|
||
printf ("%s\n", cmeta);
|
||
free (cmeta);
|
||
}
|
||
else
|
||
rc += testfailed ("ionu_eye_get_meta_data", cionu);
|
||
|
||
// Verify list of file names
|
||
cmeta = ionu_eyefile_get_filenames (cionu);
|
||
if (cmeta) {
|
||
printf ("%s\n", cmeta);
|
||
free (cmeta);
|
||
}
|
||
else
|
||
rc += testfailed ("ionu_eyefile_get_filenames", cionu);
|
||
|
||
cmeta = ionu_eyefile_get_file_objects (cionu);
|
||
if (cmeta) {
|
||
printf ("%s\n", cmeta);
|
||
free (cmeta);
|
||
}
|
||
else
|
||
rc += testfailed ("ionu_eyefile_get_file_objects", cionu);
|
||
|
||
const char* chatbot = "I'm a robot and I love to chat with other bots";
|
||
size_t chatsize = strlen (chatbot);
|
||
|
||
// Replace the permissions, which should change the tgisig
|
||
cmeta = ionu_eyefile_get_meta_data (cionu);
|
||
ionu_eyefile_replace_perms (cionu, PERMS3);
|
||
coldmeta = ionu_eyefile_get_meta_data (cionu);
|
||
if (sequencelogic::StrCmp (coldmeta, cmeta) == 0)
|
||
rc += testfailed ("ionu_eyefile_replace_perms TGI sig unchanged", cionu);
|
||
free (cmeta);
|
||
free (coldmeta);
|
||
|
||
coldmeta = ionu_eyefile_get_perms (cionu);
|
||
if (ionu_eyefile_shred_contents (cionu, TGIkey, shredurn)) {
|
||
if (ionu_eyefile_get_status (cionu) != SHREDDED)
|
||
rc += testfailed ("ionu_eyefile_get_status", "shredded");
|
||
cmeta = ionu_eyefile_get_filenames (cionu);
|
||
if (cmeta && strcmp (cmeta, "[]") != 0)
|
||
rc += testfailed ("ionu_eyefile_shred_contents []", cmeta);
|
||
// Verify meta data
|
||
cmeta = ionu_eyefile_get_meta_data (cionu);
|
||
if (cmeta) {
|
||
if (! strstr (cmeta, "status\":\"deleted"))
|
||
rc += testfailed ("ionu_eyefile_shred_contents deleted", cmeta);
|
||
free (cmeta);
|
||
}
|
||
else
|
||
rc += testfailed ("ionu_eyefile_get_meta_data after shred", cionu);
|
||
|
||
// Verify perms
|
||
cmeta = ionu_eyefile_get_perms (cionu);
|
||
if (cmeta) {
|
||
if (sequencelogic::StrCmp (coldmeta, cmeta) != 0)
|
||
rc += testfailed ("ionu_eyefile_shred_contents perms", cmeta);
|
||
free (cmeta);
|
||
}
|
||
else
|
||
rc += testfailed ("ionu_eyefile_get_perms after shred", cionu);
|
||
}
|
||
else
|
||
rc += testfailed ("ionu_eyefile_shred_contents failed", cionu);
|
||
free (coldmeta);
|
||
|
||
// Try adding a message to shredded container
|
||
if (ionu_eyefile_add_message (cionu, TGIkey, "1000's", chatbot, chatsize))
|
||
rc += testfailed ("ionu_eyefile_add_message to shredded container", cionu);
|
||
|
||
coldmeta = ionu_eyefile_get_meta_data (cionu);
|
||
ionu_eyefile_replace_meta_data (cionu, megaMeta);
|
||
cmeta = ionu_eyefile_get_meta_data (cionu);
|
||
// Shredded container, so it should fail to update
|
||
if (sequencelogic::StrCmp (coldmeta, cmeta) != 0)
|
||
rc += testfailed ("ionu_eyefile_shred_contents replace meta data", cionu);
|
||
free (coldmeta);
|
||
free (cmeta);
|
||
|
||
ionu_eyefile_create_with_message (cionu, TGIkey, "1000's", chatbot, chatsize, URN1, PERMS);
|
||
//for (int i = 0; i < 1000; ++i) { // Verified with 1,000, but just use 10 for regular test runs
|
||
for (int i = 0; i < 10; ++i) {
|
||
ionu_eyefile_add_message (cionu, TGIkey, "1000's", chatbot, chatsize);
|
||
char* msg = ionu_eyefile_get_message (cionu, TGIkey, "1000's");
|
||
if (sequencelogic::MemCmp (msg, chatbot, chatsize) != 0) {
|
||
rc += testfailed ("Get1000Messages", chatbot);
|
||
}
|
||
if (msg) free (msg);
|
||
}
|
||
ionu_eyefile_add_message (cionu, TGIkey, "1000's", "Short chat", 10);
|
||
cmeta = ionu_eyefile_get_message (cionu, TGIkey, "1000's");
|
||
if (sequencelogic::MemCmp (cmeta, "Short chat", 10) != 0) {
|
||
rc += testfailed ("Get1000Messages", "Short chat");
|
||
}
|
||
if (cmeta) free (cmeta);
|
||
cmeta = ionu_eyefile_get_meta_data (cionu);
|
||
if (cmeta) {
|
||
printf ("%s\n", cmeta);
|
||
free (cmeta);
|
||
}
|
||
//long ms = sequencelogic::GetSystemTime();
|
||
//for (int i=0; i<10000; ++i) {
|
||
// meta = ionu_eyefile_get_meta_data (cionu);
|
||
// free (meta);
|
||
//}
|
||
//ms = sequencelogic::GetSystemTime() - ms;
|
||
//printf ("get_meta_data() 10,000 values in %ld ms\n", ms);
|
||
|
||
if (! ionu_eyefile_create_with_message (cionu, TGIkey, "Empty", "", 0, URN1, PERMS))
|
||
rc += testfailed ("ionu_eye_create_with_message", "Empty");
|
||
cmsg = ionu_eyefile_get_message (cionu, TGIkey, "Empty");
|
||
if (cmsg && *cmsg == '\0') {
|
||
printf ("Empty message passed <>\n");
|
||
free (cmsg);
|
||
}
|
||
else
|
||
rc += testfailed ("ionu_eye_get_message", "Empty");
|
||
ionu_eyefile_replace_meta_data (cionu, megaMeta);
|
||
cmeta = ionu_eyefile_get_meta_data (cionu);
|
||
if (cmeta) {
|
||
printf ("%s\n", cmeta);
|
||
free (cmeta);
|
||
}
|
||
else
|
||
rc += testfailed ("ionu_eyefile_replace_meta_data", cionu);
|
||
|
||
ionu_eyefile_create_with_message (yoionu, TGIkey, ".imchat", "Yo!", 3, URN, PERMS);
|
||
cmsg = ionu_eyefile_get_message (yoionu, TGIkey, ".imchat");
|
||
if (!cmsg || strcmp (cmsg, "Yo!") != 0)
|
||
rc += testfailed ("ionu_eye_get_message", "Yo!");
|
||
if (cmsg) free (cmsg);
|
||
cmsg = ionu_eyefile_get_message ("test/yo_eyecontainer.ionu", TGIkey, ".imchat");
|
||
if (!cmsg || strcmp (cmsg, "Yo!") != 0)
|
||
rc += testfailed ("ionu_eye_get_message - EyeContainer", "Yo!");
|
||
if (cmsg) free (cmsg);
|
||
if (ionu_eyefile_get_content_and_write_to_file ("test/yo_eyecontainer.ionu", badkey, ".imchat", "test/chat"))
|
||
rc += testfailed ("ionu_eyefile_get_content_and_write_to_file - EyeContainer", "Yo!");
|
||
|
||
// Invalid argument and modified file tests
|
||
printf ("Invalid argument tests\n-------------------------------\n");
|
||
if (ionu_eyefile_get_message (cionu, TGIkey, NULL))
|
||
rc += testfailed ("ionu_eye_get_message", "extracted NULL");
|
||
if (ionu_eyefile_get_message (cionu, NULL, "Empty"))
|
||
rc += testfailed ("ionu_eye_get_message", "NULL key");
|
||
if (ionu_eyefile_get_message (NULL, TGIkey, "Empty"))
|
||
rc += testfailed ("ionu_eye_get_message", "NULL .ionu");
|
||
if (ionu_eyefile_get_message (empty_ionu, TGIkey, "Empty"))
|
||
rc += testfailed ("ionu_eye_get_message", "empty .ionu");
|
||
if (ionu_eyefile_get_meta_data (empty_ionu))
|
||
rc += testfailed ("ionu_eyefile_get_meta_data", "empty .ionu");
|
||
if (ionu_eyefile_get_filenames (empty_ionu))
|
||
rc += testfailed ("ionu_eyefile_get_filenames", "empty .ionu");
|
||
if (ionu_eyefile_get_message ("", TGIkey, "Empty"))
|
||
rc += testfailed ("ionu_eye_get_message", "empty .ionu");
|
||
if (ionu_eyefile_get_message ("this path does not exist/test.ionu", TGIkey, "Empty"))
|
||
rc += testfailed ("ionu_eye_get_message", "this path does not exist .ionu");
|
||
if (ionu_eyefile_get_message ((char*)TGIkey, TGIkey, "Empty"))
|
||
rc += testfailed ("ionu_eye_get_message", "bad .ionu");
|
||
if (ionu_eyefile_get_message ("test\ncionu", TGIkey, "Empty"))
|
||
rc += testfailed ("ionu_eye_get_message", "bad file path");
|
||
if (ionu_eyefile_get_message (cionu, TGIkey, "bogus"))
|
||
rc += testfailed ("ionu_eye_get_message", "extracted bogus");
|
||
if (ionu_eyefile_extract_file (cionu, TGIkey, (char*)TGIkey))
|
||
rc += testfailed ("ionu_eye_extract_file", "extracted TGIkey");
|
||
if (ionu_eyefile_extract_file (cionu, TGIkey, "bogus"))
|
||
rc += testfailed ("ionu_eye_extract_file", "extracted bogus");
|
||
if (ionu_eyefile_create_with_file (cionu, TGIkey, NULL, "test/plain", URN, PERMS))
|
||
rc += testfailed ("ionu_eye_create_with_file", "added NULL");
|
||
if (ionu_eyefile_create_with_file (cionu, TGIkey, "bogus", "test/plain", URN, PERMS))
|
||
rc += testfailed ("ionu_eye_create_with_file", "added bogus");
|
||
if (ionu_eyefile_get_message (perm_mods, TGIkey, "Empty"))
|
||
rc += testfailed ("ionu_eyefile_get_message", perm_mods);
|
||
if (ionu_eyefile_get_message (meta_corrupt, TGIkey, "Empty"))
|
||
rc += testfailed ("ionu_eyefile_get_message", meta_corrupt);
|
||
if (ionu_eyefile_get_message (fek_corrupt, TGIkey, "Empty"))
|
||
rc += testfailed ("ionu_eye_get_message", "fek_corrupt");
|
||
if (ionu_eyefile_get_meta_data (chksum_corrupt))
|
||
rc += testfailed ("ionu_eye_get_meta_data", "chksum_corrupt");
|
||
if (ionu_eyefile_get_message (chksum_corrupt, TGIkey, "Empty"))
|
||
rc += testfailed ("ionu_eye_get_message", "chksum_corrupt");
|
||
|
||
if (rc == 0)
|
||
printf ("\nEyeContainer interface tests passed\n-------------------------------\n");
|
||
else
|
||
printf ("\n%d EyeContainer interface tests failed\n-------------------------------\n", rc);
|
||
*/
|
||
return rc;
|
||
}
|
||
|
||
void GeneratePattern (unsigned char* buffer, std::streamoff spos)
|
||
{
|
||
char posbuf[16];
|
||
sprintf (posbuf, "%08lx", spos);
|
||
memcpy (buffer, posbuf, 8);
|
||
}
|
||
|
||
int RandomStreamTest (const std::string& sentry, size_t chunk, size_t chunks, unsigned char* rbuffer, unsigned char* wbuffer)
|
||
{
|
||
int rc = 0;
|
||
/*
|
||
std::vector<std::streamoff> positions;
|
||
std::streamoff spos = 0;
|
||
size_t i = 0;
|
||
for (i = 0; i < chunks; ++i) {
|
||
positions.push_back (spos);
|
||
spos += chunk;
|
||
}
|
||
for (i = 0; i < chunks * 100; ++i) {
|
||
size_t a = rand() % positions.size();
|
||
size_t b = rand() % positions.size();
|
||
if (a != b) {
|
||
std::streamoff save = positions[a];
|
||
positions[a] = positions[b];
|
||
positions[b] = save;
|
||
}
|
||
}
|
||
memset (rbuffer, '1', chunk);
|
||
memset (wbuffer, '1', chunk);
|
||
Key tgi ("tgi", "stream", SL_AES_KEY_LEN, TGIkey, Key::AES);
|
||
EyeContainer* eye = new EyeContainer("test/performance.ionu", tgi, URN, PERMS);
|
||
eye->SetStreamSize (sentry, chunk * chunks);
|
||
cout << "RandomStreamTest - streamsize " << eye->GetStreamSize(sentry) << endl;
|
||
|
||
// Write the random blocks
|
||
size_t nwritten = 0;
|
||
for (i = 0; i < chunks; ++i) {
|
||
spos = positions[i];
|
||
GeneratePattern (wbuffer, spos);
|
||
eye->WriteStream (sentry, spos, wbuffer, chunk, &nwritten);
|
||
if (nwritten != chunk) {
|
||
IONUDEBUG ("FAILED: RandomStreamTest() - wrote %d of %d at %d", nwritten, chunk, spos);
|
||
rc++;
|
||
break;
|
||
}
|
||
}
|
||
|
||
// Read them and verify content match
|
||
for (i = 0; i < chunks; ++i) {
|
||
spos = positions[i];
|
||
eye->ReadStream (sentry, spos, rbuffer, chunk, &nwritten);
|
||
if (nwritten != chunk) {
|
||
IONUDEBUG ("FAILED: RandomStreamTest() - read %d of %d at %d", nwritten, chunk, spos);
|
||
rc++;
|
||
break;
|
||
}
|
||
GeneratePattern (wbuffer, spos);
|
||
if (memcmp (wbuffer, rbuffer, nwritten) != 0) {
|
||
IONUDEBUG ("FAILED: RandomStreamTest() - read/write mismatch, before flush in block starting at %d of size %d", spos, nwritten);
|
||
rc++;
|
||
size_t badbytes = 0;
|
||
std::streamoff badpos = spos;
|
||
for (size_t j = 0; j < chunk; ++j) {
|
||
if (rbuffer[j] != '1') {
|
||
if (badbytes == 0)
|
||
badpos += j;
|
||
badbytes++;
|
||
}
|
||
}
|
||
if (badbytes > 0) {
|
||
IONUDEBUG ("RandomStreamTest() - %d bytes starting at %d", badbytes, badpos);
|
||
}
|
||
}
|
||
}
|
||
|
||
// Flush to disk and verify read again
|
||
eye->Flush();
|
||
delete eye;
|
||
eye = new EyeContainer("test/performance.ionu", tgi);
|
||
for (i = 0; i < chunks; ++i) {
|
||
spos = positions[i];
|
||
eye->ReadStream (sentry, spos, rbuffer, chunk, &nwritten);
|
||
if (nwritten != chunk) {
|
||
IONUDEBUG ("FAILED: RandomStreamTest() - read after flush %d of %d at %d on block %d", nwritten, chunk, spos, i);
|
||
rc++;
|
||
break;
|
||
}
|
||
GeneratePattern (wbuffer, spos);
|
||
if (memcmp (wbuffer, rbuffer, nwritten) != 0) {
|
||
IONUDEBUG ("FAILED: RandomStreamTest() - read/write mismatch, after flush in block %d starting at %d of size %d", i, spos, nwritten);
|
||
rc++;
|
||
size_t badbytes = 0;
|
||
std::streamoff badpos = spos;
|
||
for (size_t j = 0; j < chunk; ++j) {
|
||
if (rbuffer[j] != '1') {
|
||
if (badbytes == 0)
|
||
badpos += j;
|
||
badbytes++;
|
||
}
|
||
}
|
||
if (badbytes > 0) {
|
||
IONUDEBUG ("RandomStreamTest() - %d bytes starting at %d", badbytes, badpos);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
delete eye;
|
||
|
||
// Verify readonly
|
||
eye = new EyeContainer("test/performance.ionu", tgi, ios::in);
|
||
for (i = 0; i < chunks; ++i) {
|
||
spos = positions[i];
|
||
eye->ReadStream (sentry, spos, rbuffer, chunk, &nwritten);
|
||
if (nwritten != chunk) {
|
||
IONUDEBUG ("FAILED: RandomStreamTest() - readonly read %d of %d at %d", nwritten, chunk, spos);
|
||
rc++;
|
||
break;
|
||
}
|
||
GeneratePattern (wbuffer, spos);
|
||
if (memcmp (wbuffer, rbuffer, nwritten) != 0) {
|
||
IONUDEBUG ("FAILED: RandomStreamTest() - read/write mismatch, readonly in block starting at %d of size %d", spos, nwritten);
|
||
rc++;
|
||
size_t badbytes = 0;
|
||
std::streamoff badpos = spos;
|
||
for (size_t j = 0; j < chunk; ++j) {
|
||
if (rbuffer[j] != '1') {
|
||
if (badbytes == 0)
|
||
badpos += j;
|
||
badbytes++;
|
||
}
|
||
}
|
||
if (badbytes > 0) {
|
||
IONUDEBUG ("RandomStreamTest() - %d bytes starting at %d", badbytes, badpos);
|
||
}
|
||
}
|
||
}
|
||
delete eye;
|
||
*/
|
||
return rc;
|
||
}
|
||
|
||
// Sequential read, with readonly file, verify data with expected value
|
||
bool StreamVerify (const std::string& sentry, size_t chunk, size_t chunks, unsigned char* rbuffer, unsigned char* wbuffer)
|
||
{
|
||
bool rc = true;
|
||
/*
|
||
size_t nwritten = 0;
|
||
std::streamoff spos = 0;
|
||
Key tgi ("tgi", "stream", SL_AES_KEY_LEN, TGIkey, Key::AES);
|
||
|
||
EyeContainer* eye = new EyeContainer("test/performance.ionu", tgi, ios::in);
|
||
for (size_t i = 0; i < chunks; ++i) {
|
||
spos = i * chunk;
|
||
GeneratePattern (wbuffer, spos);
|
||
eye->ReadStream (sentry, spos, rbuffer, chunk, &nwritten);
|
||
if (nwritten != chunk) {
|
||
IONUDEBUG ("FAILED: StreamVerify() - read %d of %d at %d", nwritten, chunk, spos);
|
||
break;
|
||
}
|
||
if (memcmp (wbuffer, rbuffer, nwritten) != 0) {
|
||
rc = false;
|
||
IONUDEBUG ("FAILED: StreamVerify() - read/write mismatch in block starting at %d of size %d", spos, nwritten);
|
||
size_t badbytes = 0;
|
||
std::streamoff badpos = spos;
|
||
for (size_t j = 0; j < chunk; ++j) {
|
||
if (rbuffer[j] != wbuffer[j]) {
|
||
if (badbytes == 0)
|
||
badpos += j;
|
||
badbytes++;
|
||
}
|
||
}
|
||
if (badbytes > 0) {
|
||
IONUDEBUG ("FAILED: StreamVerify() - %d bytes starting at %d", badbytes, badpos);
|
||
}
|
||
}
|
||
}
|
||
delete eye;
|
||
*/
|
||
return rc;
|
||
}
|
||
|
||
int PerformanceTest()
|
||
{
|
||
printf ("\nSpeed Testin stream interfaces\n-------------------------------\n");
|
||
int rc = 0;
|
||
/*
|
||
size_t chunk = IONU_EYE_STREAM_CHUNK/4;
|
||
size_t chunks = 98;
|
||
EyeContainer* IOnU = NULL;
|
||
std::string sentry ("stream");
|
||
std::streamoff spos = 0;
|
||
std::string baseline = "";
|
||
std::string digest = "";
|
||
size_t nwritten = 0;
|
||
Key junk;
|
||
Key tgi ("tgi", "stream", SL_AES_KEY_LEN, TGIkey, Key::AES);
|
||
unsigned char iv[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 'a', 'b', 'c', 'd', 'e', 'f'};
|
||
unsigned char* rbuffer = sequencelogic::New (chunk);
|
||
unsigned char* wbuffer = sequencelogic::New (chunk);
|
||
memset (wbuffer, '1', chunk);
|
||
std::chrono::high_resolution_clock::time_point begin;
|
||
std::chrono::high_resolution_clock::time_point end;
|
||
std::chrono::duration<double> time_span;
|
||
|
||
// Sequential write
|
||
begin = std::chrono::high_resolution_clock::now();
|
||
IOnU = new EyeContainer("test/performance.ionu", tgi, URN, PERMS);
|
||
for (size_t i = 0; i < chunks; ++i) {
|
||
spos = i * chunk;
|
||
GeneratePattern (wbuffer, spos);
|
||
IOnU->WriteStream (sentry, spos, wbuffer, chunk, &nwritten);
|
||
if (nwritten != chunk) {
|
||
IONUDEBUG ("PerformanceTest() - wrote %d of %d", nwritten, chunk);
|
||
break;
|
||
}
|
||
}
|
||
//IOnU->WriteStream (sentry, chunk * chunks, wbuffer, 3, &nwritten);
|
||
IOnU->Finalize();
|
||
delete IOnU;
|
||
end = std::chrono::high_resolution_clock::now();
|
||
time_span = std::chrono::duration_cast<std::chrono::duration<double>>(end - begin);
|
||
cout << "Sequential write in " << time_span.count() << " seconds" << endl;
|
||
|
||
// Get baseline hash
|
||
IOnU = new EyeContainer("test/performance.ionu", tgi, ios::in);
|
||
IOnU->ExtractFile (sentry);
|
||
//unsigned char* membuf = IOnU->ExtractMemoryFile (sentry, &nwritten);
|
||
delete IOnU;
|
||
//if (membuf) delete[] membuf;
|
||
begin = std::chrono::high_resolution_clock::now();
|
||
baseline = sequencelogic::DigestFile ("sha1", "stream");
|
||
cout << baseline << endl;
|
||
end = std::chrono::high_resolution_clock::now();
|
||
time_span = std::chrono::duration_cast<std::chrono::duration<double>>(end - begin);
|
||
cout << "Digested in " << time_span.count() << " seconds" << endl;
|
||
|
||
begin = std::chrono::high_resolution_clock::now();
|
||
if (!StreamVerify (sentry, chunk, chunks, rbuffer, wbuffer))
|
||
rc++;
|
||
end = std::chrono::high_resolution_clock::now();
|
||
time_span = std::chrono::duration_cast<std::chrono::duration<double>>(end - begin);
|
||
cout << "Sequential readonly in " << time_span.count() << " seconds" << endl;
|
||
|
||
// Raw file encryption time
|
||
begin = std::chrono::high_resolution_clock::now();
|
||
tgi.SymmetricEncryptFile ("stream", "estream", iv);
|
||
end = std::chrono::high_resolution_clock::now();
|
||
time_span = std::chrono::duration_cast<std::chrono::duration<double>>(end - begin);
|
||
cout << "Encrypted in " << time_span.count() << " seconds" << endl;
|
||
begin = std::chrono::high_resolution_clock::now();
|
||
tgi.SymmetricDecryptFile ("estream", "stream", iv);
|
||
end = std::chrono::high_resolution_clock::now();
|
||
time_span = std::chrono::duration_cast<std::chrono::duration<double>>(end - begin);
|
||
cout << "Decrypted in " << time_span.count() << " seconds" << endl;
|
||
digest = sequencelogic::DigestFile ("sha1", "stream");
|
||
if (digest != baseline)
|
||
cout << "FAIL: digest mismatch " << digest << " expected " << baseline << endl;
|
||
|
||
// Random write/read tests
|
||
begin = std::chrono::high_resolution_clock::now();
|
||
rc += RandomStreamTest (sentry, chunk, chunks, rbuffer, wbuffer);
|
||
IOnU = new EyeContainer("test/performance.ionu", tgi, ios::in);
|
||
IOnU->ExtractFile (sentry);
|
||
delete IOnU;
|
||
digest = sequencelogic::DigestFile ("sha1", "stream");
|
||
if (digest != baseline)
|
||
cout << "FAIL: digest mismatch " << digest << " expected " << baseline << endl;
|
||
end = std::chrono::high_resolution_clock::now();
|
||
time_span = std::chrono::duration_cast<std::chrono::duration<double>>(end - begin);
|
||
cout << "Random stream test in " << time_span.count() << " seconds" << endl;
|
||
|
||
// Reverse write new stream
|
||
begin = std::chrono::high_resolution_clock::now();
|
||
IOnU = new EyeContainer("test/performance.ionu", tgi, URN, PERMS);
|
||
IOnU->SetStreamSize (sentry, chunk * chunks);
|
||
for (int i = chunks - 1; i >= 0; --i) {
|
||
spos = i * chunk;
|
||
GeneratePattern (wbuffer, spos);
|
||
IOnU->WriteStream (sentry, spos, wbuffer, chunk, &nwritten);
|
||
if (nwritten != chunk) {
|
||
IONUDEBUG ("PerformanceTest() - wrote %d of %d at %d", nwritten, chunk, spos);
|
||
break;
|
||
}
|
||
}
|
||
IOnU->Finalize();
|
||
delete IOnU;
|
||
end = std::chrono::high_resolution_clock::now();
|
||
time_span = std::chrono::duration_cast<std::chrono::duration<double>>(end - begin);
|
||
cout << "Reverse write in " << time_span.count() << " seconds" << endl;
|
||
IOnU = new EyeContainer("test/performance.ionu", tgi, ios::in);
|
||
IOnU->ExtractFile (sentry);
|
||
delete IOnU;
|
||
digest = sequencelogic::DigestFile ("sha1", "stream");
|
||
if (digest != baseline)
|
||
cout << "FAIL: digest mismatch " << digest << " expected " << baseline << endl;
|
||
if (!StreamVerify (sentry, chunk, chunks, rbuffer, wbuffer))
|
||
rc++;
|
||
|
||
// Skip write in existing stream
|
||
begin = std::chrono::high_resolution_clock::now();
|
||
IOnU = new EyeContainer("test/performance.ionu", tgi);
|
||
for (size_t i = 0; i < chunks; i += 4) {
|
||
spos = i * chunk;
|
||
GeneratePattern (wbuffer, spos);
|
||
IOnU->WriteStream (sentry, spos, wbuffer, chunk, &nwritten);
|
||
if (nwritten != chunk) {
|
||
IONUDEBUG ("PerformanceTest() - wrote %d of %d", nwritten, chunk);
|
||
break;
|
||
}
|
||
}
|
||
IOnU->Finalize();
|
||
delete IOnU;
|
||
end = std::chrono::high_resolution_clock::now();
|
||
time_span = std::chrono::duration_cast<std::chrono::duration<double>>(end - begin);
|
||
cout << "Skip 4 write in " << time_span.count() << " seconds" << endl;
|
||
|
||
if (!StreamVerify (sentry, chunk, chunks, rbuffer, wbuffer))
|
||
rc++;
|
||
|
||
IOnU = new EyeContainer("test/performance.ionu", tgi, ios::in);
|
||
IOnU->ExtractFile (sentry);
|
||
delete IOnU;
|
||
digest = sequencelogic::DigestFile ("sha1", "stream");
|
||
if (digest != baseline)
|
||
cout << "FAIL: digest mismatch " << digest << " expected " << baseline << endl;
|
||
|
||
begin = std::chrono::high_resolution_clock::now();
|
||
cout << EyeContainer::GetMetaData ("test/performance.ionu", ".ionumeta", tgi) << endl;
|
||
end = std::chrono::high_resolution_clock::now();
|
||
time_span = std::chrono::duration_cast<std::chrono::duration<double>>(end - begin);
|
||
cout << "GetMetaData in " << time_span.count() << " seconds" << endl;
|
||
|
||
// Verify baseline hash
|
||
IOnU = new EyeContainer("test/performance.ionu", tgi, ios::in);
|
||
IOnU->ExtractFile (sentry);
|
||
delete IOnU;
|
||
digest = sequencelogic::DigestFile ("sha1", "stream");
|
||
if (digest != baseline)
|
||
cout << "FAIL: digest mismatch " << digest << " expected " << baseline << endl;
|
||
|
||
// Skip read
|
||
begin = std::chrono::high_resolution_clock::now();
|
||
IOnU = new EyeContainer("test/performance.ionu", tgi);
|
||
for (size_t i = 0; i < chunks; i += 4) {
|
||
spos = i * chunk;
|
||
GeneratePattern (wbuffer, spos);
|
||
IOnU->ReadStream (sentry, spos, rbuffer, chunk, &nwritten);
|
||
if (nwritten != chunk) {
|
||
IONUDEBUG ("PerformanceTest() - read %d of %d", nwritten, chunk);
|
||
break;
|
||
}
|
||
if (memcmp (wbuffer, rbuffer, nwritten) != 0) {
|
||
IONUDEBUG ("PerformanceTest() - read/write mismatch in block starting at %d of size %d", spos, nwritten);
|
||
size_t badbytes = 0;
|
||
std::streamoff badpos = spos;
|
||
for (size_t j = 0; j < chunk; ++j) {
|
||
if (rbuffer[j] != wbuffer[j]) {
|
||
if (badbytes == 0)
|
||
badpos += j;
|
||
badbytes++;
|
||
}
|
||
}
|
||
if (badbytes > 0) {
|
||
IONUDEBUG ("PerformanceTest() - %d bytes starting at %d", badbytes, badpos);
|
||
}
|
||
}
|
||
}
|
||
delete IOnU;
|
||
end = std::chrono::high_resolution_clock::now();
|
||
time_span = std::chrono::duration_cast<std::chrono::duration<double>>(end - begin);
|
||
cout << "Skip 4 read in " << time_span.count() << " seconds" << endl;
|
||
|
||
// Reverse read
|
||
begin = std::chrono::high_resolution_clock::now();
|
||
IOnU = new EyeContainer("test/performance.ionu", tgi, ios::in | ios::out);
|
||
for (int i = chunks - 1; i >= 0; --i) {
|
||
spos = i * chunk;
|
||
GeneratePattern (wbuffer, spos);
|
||
IOnU->ReadStream (sentry, spos, rbuffer, chunk, &nwritten);
|
||
if (nwritten != chunk) {
|
||
IONUDEBUG ("PerformanceTest() - read %d of %d at %d", nwritten, chunk, spos);
|
||
break;
|
||
}
|
||
if (memcmp (wbuffer, rbuffer, nwritten) != 0) {
|
||
IONUDEBUG ("PerformanceTest() - read/write mismatch in block starting at %d of size %d", spos, nwritten);
|
||
size_t badbytes = 0;
|
||
std::streamoff badpos = spos;
|
||
for (size_t j = 0; j < chunk; ++j) {
|
||
if (rbuffer[j] != wbuffer[j]) {
|
||
if (badbytes == 0)
|
||
badpos += j;
|
||
badbytes++;
|
||
}
|
||
}
|
||
if (badbytes > 0) {
|
||
IONUDEBUG ("PerformanceTest() - %d bytes starting at %d", badbytes, badpos);
|
||
}
|
||
|
||
}
|
||
}
|
||
delete IOnU;
|
||
end = std::chrono::high_resolution_clock::now();
|
||
time_span = std::chrono::duration_cast<std::chrono::duration<double>>(end - begin);
|
||
cout << "Reverse read in " << time_span.count() << " seconds" << endl;
|
||
|
||
// Extract plaintext file
|
||
begin = std::chrono::high_resolution_clock::now();
|
||
IOnU = new EyeContainer("test/performance.ionu", tgi, ios::in);
|
||
IOnU->ExtractFile (sentry);
|
||
delete IOnU;
|
||
end = std::chrono::high_resolution_clock::now();
|
||
time_span = std::chrono::duration_cast<std::chrono::duration<double>>(end - begin);
|
||
cout << "Extracted in " << time_span.count() << " seconds" << endl;
|
||
|
||
begin = std::chrono::high_resolution_clock::now();
|
||
digest = sequencelogic::DigestFile ("sha1", "stream");
|
||
if (digest != baseline)
|
||
cout << "FAIL: digest mismatch " << digest << " expected " << baseline << endl;
|
||
end = std::chrono::high_resolution_clock::now();
|
||
time_span = std::chrono::duration_cast<std::chrono::duration<double>>(end - begin);
|
||
cout << "Digested in " << time_span.count() << " seconds" << endl;
|
||
|
||
// Add plaintext file
|
||
begin = std::chrono::high_resolution_clock::now();
|
||
IOnU = new EyeContainer("test/performance.ionu", tgi, URN, PERMS);
|
||
IOnU->AddContent (sentry, "text/stream");
|
||
IOnU->Finalize();
|
||
delete IOnU;
|
||
end = std::chrono::high_resolution_clock::now();
|
||
time_span = std::chrono::duration_cast<std::chrono::duration<double>>(end - begin);
|
||
cout << "Added in " << time_span.count() << " seconds" << endl;
|
||
|
||
begin = std::chrono::high_resolution_clock::now();
|
||
IOnU = new EyeContainer("test/performance.ionu", tgi);
|
||
IOnU->AddContent (sentry, "text/stream");
|
||
IOnU->Finalize();
|
||
delete IOnU;
|
||
end = std::chrono::high_resolution_clock::now();
|
||
time_span = std::chrono::duration_cast<std::chrono::duration<double>>(end - begin);
|
||
cout << "Replaced in " << time_span.count() << " seconds" << endl;
|
||
cout << EyeContainer::GetMetaData ("test/performance.ionu", ".ionumeta", tgi) << endl;
|
||
|
||
// Sequential read, with read/write file
|
||
begin = std::chrono::high_resolution_clock::now();
|
||
IOnU = new EyeContainer("test/performance.ionu", tgi, ios::in | ios::out);
|
||
for (int i = 0; i < chunks; ++i) {
|
||
spos = i * chunk;
|
||
GeneratePattern (wbuffer, spos);
|
||
IOnU->ReadStream (sentry, spos, rbuffer, chunk, &nwritten);
|
||
if (nwritten != chunk) {
|
||
IONUDEBUG ("PerformanceTest() - read %d of %d at %d", nwritten, chunk, spos);
|
||
break;
|
||
}
|
||
if (memcmp (wbuffer, rbuffer, nwritten) != 0) {
|
||
IONUDEBUG ("PerformanceTest() - read/write mismatch in block starting at %d of size %d", spos, nwritten);
|
||
size_t badbytes = 0;
|
||
std::streamoff badpos = spos;
|
||
for (size_t j = 0; j < chunk; ++j) {
|
||
if (rbuffer[j] != '1') {
|
||
if (badbytes == 0)
|
||
badpos += j;
|
||
badbytes++;
|
||
}
|
||
}
|
||
if (badbytes > 0) {
|
||
IONUDEBUG ("PerformanceTest() - %d bytes starting at %d", badbytes, badpos);
|
||
}
|
||
}
|
||
}
|
||
delete IOnU;
|
||
end = std::chrono::high_resolution_clock::now();
|
||
time_span = std::chrono::duration_cast<std::chrono::duration<double>>(end - begin);
|
||
cout << "Sequential read in " << time_span.count() << " seconds" << endl;
|
||
|
||
// Reverse write with SetStreamSize()
|
||
begin = std::chrono::high_resolution_clock::now();
|
||
IOnU = new EyeContainer("test/performance.ionu", tgi, URN, PERMS);
|
||
IOnU->SetStreamSize (sentry, chunk * chunks);
|
||
for (int i = chunks - 1; i >= 0; --i) {
|
||
spos = i * chunk;
|
||
GeneratePattern (wbuffer, spos);
|
||
IOnU->WriteStream (sentry, spos, wbuffer, chunk, &nwritten);
|
||
if (nwritten != chunk) {
|
||
IONUDEBUG ("PerformanceTest() - wrote %d of %d at %d", nwritten, chunk, spos);
|
||
break;
|
||
}
|
||
}
|
||
IOnU->Finalize();
|
||
delete IOnU;
|
||
end = std::chrono::high_resolution_clock::now();
|
||
time_span = std::chrono::duration_cast<std::chrono::duration<double>>(end - begin);
|
||
cout << "Reverse write, SetStreamSize in " << time_span.count() << " seconds" << endl;
|
||
if (!StreamVerify (sentry, chunk, chunks, rbuffer, wbuffer))
|
||
rc++;
|
||
#ifdef SLOW
|
||
// Reverse write
|
||
begin = std::chrono::high_resolution_clock::now();
|
||
IOnU = new EyeContainer("test/performance.ionu", tgi, ios::in | ios::out);
|
||
for (int i = chunks - 1; i >= 0; --i) {
|
||
spos = i * chunk;
|
||
GeneratePattern (wbuffer, spos);
|
||
IOnU->WriteStream (sentry, spos, rbuffer, chunk, &nwritten);
|
||
if (nwritten != chunk) {
|
||
IONUDEBUG ("PerformanceTest() - wrote %d of %d at %d", nwritten, chunk, spos);
|
||
break;
|
||
}
|
||
}
|
||
IOnU->Finalize();
|
||
delete IOnU;
|
||
end = std::chrono::high_resolution_clock::now();
|
||
time_span = std::chrono::duration_cast<std::chrono::duration<double>>(end - begin);
|
||
cout << "Reverse write in " << time_span.count() << " seconds" << endl;
|
||
EyeContainer::UpdateMetaData ("test/performance.ionu", ".ionumeta", "{\"urn\":\"urn:sl:FFFFFF:FFFFFFFF:ALAN:FROSTFFFFFFF\"}", junk);
|
||
|
||
// Verify that reverse write worked
|
||
IOnU = new EyeContainer("test/performance.ionu", tgi, ios::in);
|
||
IOnU->ExtractFile (sentry);
|
||
membuf = IOnU->ExtractMemoryFile (sentry, &nwritten);
|
||
delete IOnU;
|
||
if (membuf) delete[] membuf;
|
||
cout << "Extracted " << nwritten << " bytes - " << sequencelogic::DigestFile ("sha1", "stream") << endl;
|
||
|
||
// Reverse write with sequential read
|
||
begin = std::chrono::high_resolution_clock::now();
|
||
std::streamoff rpos = 0;
|
||
IOnU = new EyeContainer("test/performance.ionu", tgi, ios::in | ios::out);
|
||
for (int i = chunks - 1; i >= 0; --i) {
|
||
spos = i * chunk;
|
||
GeneratePattern (wbuffer, spos);
|
||
IOnU->WriteStream (sentry, spos, rbuffer, chunk, &nwritten);
|
||
if (nwritten != chunk) {
|
||
IONUDEBUG ("PerformanceTest() - wrote %d of %d at %d", nwritten, chunk, spos);
|
||
break;
|
||
}
|
||
IOnU->ReadStream (sentry, rpos, rbuffer, chunk, &nwritten);
|
||
rpos += chunk;
|
||
}
|
||
IOnU->Finalize();
|
||
delete IOnU;
|
||
end = std::chrono::high_resolution_clock::now();
|
||
time_span = std::chrono::duration_cast<std::chrono::duration<double>>(end - begin);
|
||
cout << "Reverse write, sequential read in " << time_span.count() << " seconds" << endl;
|
||
|
||
// Verify that reverse write with sequential read worked
|
||
IOnU = new EyeContainer("test/performance.ionu", tgi, ios::in);
|
||
IOnU->ExtractFile (sentry);
|
||
delete IOnU;
|
||
digest = sequencelogic::DigestFile ("sha1", "stream");
|
||
if (digest != baseline)
|
||
cout << "FAIL: digest mismatch " << digest << " expected " << baseline << endl;
|
||
#endif
|
||
|
||
// Test static methods for metadata, rename and permissions
|
||
cout << EyeContainer::GetMetaData ("test/performance.ionu", ".ionumeta", junk) << endl;
|
||
EyeContainer::UpdateMetaData ("test/performance.ionu", ".ionumeta", "{\"msg\":{\"drr\":true}}", junk);
|
||
cout << EyeContainer::GetMetaData ("test/performance.ionu", ".ionumeta", junk) << endl;
|
||
EyeContainer::RenameFile ("test/performance.ionu", "stream", "renamed", junk);
|
||
cout << EyeContainer::GetContentMetaData ("test/performance.ionu", "stream", junk) << endl;
|
||
EyeContainer::UpdateMetaData ("test/performance.ionu", ".ionuperm", "{\"read\":[\"00000003\",\"17C38E5A\"]}", junk);
|
||
cout << EyeContainer::GetMetaData ("test/performance.ionu", ".ionuperm", junk) << endl;
|
||
if (EyeContainer::GetStatus ("test/performance.ionu") != EyeContainer::EYE_VALID)
|
||
cout << "FAIL: invalid EyeContainer after static metadata tests" << endl;
|
||
delete[] wbuffer;
|
||
delete[] rbuffer;
|
||
|
||
if (rc == 0)
|
||
printf ("\nIVFS interface tests passed\n-------------------------------\n");
|
||
else
|
||
printf ("\n%d IVFS interface tests failed\n-------------------------------\n", rc);
|
||
*/
|
||
return rc;
|
||
}
|
||
|
||
#ifdef ALAN
|
||
void SearchQuery (EyeSearch& bing, const std::string query)
|
||
{
|
||
cout << query << " - " << bing.Search (query, 7) << endl;
|
||
}
|
||
|
||
int TestSearch()
|
||
{
|
||
int rc = 0;
|
||
#ifndef WIN32
|
||
Key tgi ("tgi", "stream", SL_AES_KEY_LEN, TGIkey, Key::AES);
|
||
EyeSearch bing ("index", tgi);
|
||
bing.IndexDocument ("test/applications.txt", "text/plain", "{\"title\":\"Applications and Tools\"}");
|
||
bing.IndexDocument ("test/authentication.txt", "text/plain", "{\"title\":\"Advanced Authentication\"}");
|
||
bing.IndexDocument ("test/cloud.txt", "text/plain", "{\"title\":\"Cloud Services\"}");
|
||
bing.IndexDocument ("test/management.txt", "text/plain", "{\"title\":\"Key Management\"}");
|
||
bing.IndexDocument ("test/mobility.txt", "text/plain", "{\"title\":\"Mobility and BYOD\"}");
|
||
bing.IndexDocument ("test/transparent.txt", "text/plain", "{\"title\":\"Transparent Encryption\"}");
|
||
bing.IndexMessage ("Message", "Secure your mobile device with IONU", "{\"title\":\"Mobile Security\"}");
|
||
bing.IndexMessage ("unCompound", "Secure your cell or mobile phone and bike for mountain with IONU", "{\"title\":\"Compound Security\"}");
|
||
bing.IndexMessage ("Compound", "Secure your cell phone and mountain bike with IONU", "{\"title\":\"Compound Security\"}");
|
||
bing.SortByRank();
|
||
bing.Dump();
|
||
SearchQuery (bing, "security");
|
||
SearchQuery (bing, "encryption");
|
||
SearchQuery (bing, "mobile security");
|
||
SearchQuery (bing, "mobile security storage");
|
||
SearchQuery (bing, "attack key encryption");
|
||
SearchQuery (bing, "cell phone");
|
||
SearchQuery (bing, "cellphone");
|
||
SearchQuery (bing, "phone");
|
||
SearchQuery (bing, "mountain bike");
|
||
EyeStemmer stem;
|
||
char* stems = fileload ("test/voc.txt");
|
||
std::string stemstr (stems, strlen (stems));
|
||
std::vector<std::string> words = SplitString (stemstr, '\n');
|
||
for (auto& word: words) {
|
||
if (word.size() > 2)
|
||
cout << stem.Stem (word) << endl;
|
||
else
|
||
cout << word << endl;
|
||
}
|
||
cout << stem.Stem ("feed") << endl;
|
||
cout << stem.Stem ("like") << endl;
|
||
cout << stem.Stem ("liked") << endl;
|
||
cout << stem.Stem ("pencils") << endl;
|
||
cout << stem.Stem ("agreed") << endl;
|
||
cout << stem.Stem ("agreeable") << endl;
|
||
cout << stem.Stem ("rationalize") << endl;
|
||
cout << stem.Stem ("rationalization") << endl;
|
||
cout << stem.Stem ("rationals") << endl;
|
||
cout << stem.Stem ("abate") << endl;
|
||
cout << stem.Stem ("windpipe") << endl;
|
||
#endif
|
||
return rc;
|
||
}
|
||
#endif
|
||
|
||
int main ()
|
||
{
|
||
int rc = 0;
|
||
Key junk;
|
||
//Key tgi ("tgi", "stream", SL_AES_KEY_LEN, TGIkey, Key::AES);
|
||
EyeLog::GetInstance()->ConfigLogger ("libeye", "test", EyeLog::IONU_DEBUG, EyeLog::IONU_CONSOLE, "%l:%c %m");
|
||
//cout << sequencelogic::GetVersionInfo() << endl;
|
||
//TestSearch();
|
||
//TestProcessLocking();
|
||
//TestFileThreadLocking();
|
||
TestFileLocking();
|
||
//TestRandom();
|
||
// TestEyeContainer();
|
||
exit (0);
|
||
/*
|
||
TestKeys();
|
||
TestMixedUpKeys();
|
||
TestEyeContainer();
|
||
PerformanceTest();
|
||
//TestSearch();
|
||
//TestRSAKeyGeneration();
|
||
ionu_eyefile_create_with_message (yoionu, TGIkey, ".imchatty", "Yo!", 3, URN, PERMS);
|
||
std::string tarjson = EyeContainer::Stringify (yoionu);
|
||
cout << tarjson << endl;
|
||
EyeContainer::Tarify ("tarjson.ionu", tarjson);
|
||
size_t rbytes;
|
||
unsigned char* rbuffer = sequencelogic::New (70000);
|
||
memset (rbuffer, '7', 70000);
|
||
EyeContainer* reye = new EyeContainer("test/rename.ionu", tgi, URN, PERMS);
|
||
reye->WriteStream ("stream", 0, rbuffer, 70000, &rbytes);
|
||
reye->Finalize();
|
||
delete reye;
|
||
std::string smallermeta = EyeContainer::GetMetaData ("test/rename.ionu", IONU_EYE_META_FILE, junk);
|
||
tarjson = EyeContainer::Stringify ("test/rename.ionu");
|
||
cout << "tarjson " << tarjson.size() << endl;
|
||
cout << tarjson.substr (0, 1024) << endl;
|
||
EyeContainer::Tarify ("tarjson.ionu", tarjson);
|
||
|
||
EyeContainer::RenameFile ("test/rename.ionu", "stream", "stream12345", junk);
|
||
EyeContainer::RenameFile ("test/rename.ionu", "stream12345", "stream123456", junk);
|
||
std::string largermeta = EyeContainer::GetMetaData ("test/rename.ionu", IONU_EYE_META_FILE, junk);
|
||
EyeContainer::RenameFile ("test/rename.ionu", "stream123456", "stream12345", junk);
|
||
EyeContainer::RenameFile ("test/rename.ionu", "stream12345", "stream", junk);
|
||
ionu_eyefile_replace_meta_data ("test/rename.ionu", largermeta.c_str());
|
||
ionu_eyefile_replace_meta_data ("test/rename.ionu", smallermeta.c_str());
|
||
ionu_eyefile_replace_meta_data ("test/empty.ionu", smallermeta.c_str());
|
||
sequencelogic::CopyFiles ("test/old.ionu", "test/oldrename.ionu");
|
||
EyeContainer* oldren = new EyeContainer ("test/oldrename.ionu", TGIkey);
|
||
oldren->RenameFile (".imchat", "renamed");
|
||
oldren->Finalize();
|
||
delete oldren;
|
||
cout << EyeContainer::GetMetaData ("test/oldrename.ionu", IONU_EYE_META_FILE, junk) << endl;
|
||
sequencelogic::RemoveFile ("test/oldrename.ionu");
|
||
sequencelogic::RemoveFile ("test/oldrename.ionu");
|
||
cout << "done" << endl;
|
||
exit (0);
|
||
|
||
exit (0);
|
||
|
||
TestFileThreadLocking();
|
||
TestFileLocking();
|
||
ionu_eyefile_create_with_message (yoionu, TGIkey, ".imchatty", "Yo!", 3, URN, PERMS);
|
||
cout << ionu_eyefile_get_message (yoionu, TGIkey, ".imchatty") << endl;
|
||
ionu_eyefile_rename_file (yoionu, ".imchatty", ".imchat");
|
||
cout << ionu_eyefile_get_message (yoionu, TGIkey, ".imchat") << endl;
|
||
|
||
Keyring rring ("js", "test");
|
||
rring.GenerateRSAKey ("bob", "bob", "IOnU,Bob,Bob,Bob");
|
||
Key rrkey;
|
||
rring.GetKey ("bob", rrkey);
|
||
rrkey.PublicKeyFingerPrint();
|
||
rring.ImportPubKeyFromCert ("test/isis.pem");
|
||
rring.GetKey ("cert", rrkey);
|
||
if (rrkey.PublicKeyFingerPrint() != "fc:34:2b:b3:a2:f6:91:c9:fb:79:16:ca:2e:d2:47:3d:b3:38:8a:b2")
|
||
rc += testfailed ("isis.nu - fc:34:2b:b3:a2:f6:91:c9:fb:79:16:ca:2e:d2:47:3d:b3:38:8a:b2", rrkey.PublicKeyFingerPrint());
|
||
exit (0);
|
||
// Test capture and replace of FEK in compressed EyeContainer
|
||
EyeContainer* rionu = new EyeContainer("test/test.ionu", TGIkey, URN, PERMS);
|
||
rionu->AddTextMessage ("Message", "Updated FEK from captured FEK after container ReKey and restore FEK");
|
||
rionu->Finalize();
|
||
delete rionu;
|
||
|
||
std::string oldfek = EyeContainer::GetMetaData ("test/test.ionu", IONU_EYE_FEK_FILE, junk);
|
||
Key bbkey ("Bad", "key", SL_AES_KEY_LEN, badkey, Key::TGI);
|
||
rionu = new EyeContainer("test/test.ionu", TGIkey);
|
||
rionu->ReKey (bbkey);
|
||
rionu->Finalize();
|
||
delete rionu;
|
||
rionu = new EyeContainer("test/test.ionu", TGIkey);
|
||
std::string rmsg = rionu->GetTextMessage ("Message");
|
||
if (rmsg.size() > 1 && rmsg[0] == 'U' && rmsg[1] == 'p')
|
||
rc += testfailed ("ReKey - old key", rmsg);
|
||
delete rionu;
|
||
EyeContainer::ReplaceMetaData ("test/test.ionu", IONU_EYE_FEK_FILE, oldfek, junk);
|
||
rionu = new EyeContainer("test/test.ionu", TGIkey);
|
||
rmsg = rionu->GetTextMessage ("Message");
|
||
if (rmsg.size() > 1 && rmsg[0] == 'U' && rmsg[1] == 'p')
|
||
cout << rmsg << endl;
|
||
delete rionu;
|
||
|
||
// Test capture and replace of FEK in uncompressed EyeContainer
|
||
rionu = new EyeContainer("test/test.ionu", TGIkey, URN, PERMS);
|
||
size_t nwritten = 0;
|
||
rionu->WriteStream ("Message", 0, "Updated FEK from captured FEK... uncompressed EyeContainer", 58, &nwritten);
|
||
rionu->Finalize();
|
||
delete rionu;
|
||
|
||
oldfek = EyeContainer::GetMetaData ("test/test.ionu", IONU_EYE_FEK_FILE, junk);
|
||
rionu = new EyeContainer("test/test.ionu", TGIkey);
|
||
rionu->ReKey (bbkey);
|
||
rionu->Finalize();
|
||
delete rionu;
|
||
rionu = new EyeContainer("test/test.ionu", TGIkey);
|
||
rmsg = rionu->GetTextMessage ("Message");
|
||
if (rmsg.size() > 1 && rmsg[0] == 'U' && rmsg[1] == 'p')
|
||
rc += testfailed ("ReKey - old key", rmsg);
|
||
delete rionu;
|
||
EyeContainer::ReplaceMetaData ("test/test.ionu", IONU_EYE_FEK_FILE, oldfek, junk);
|
||
rionu = new EyeContainer("test/test.ionu", TGIkey);
|
||
rmsg = rionu->GetTextMessage ("Message");
|
||
if (rmsg.size() > 1 && rmsg[0] == 'U' && rmsg[1] == 'p')
|
||
cout << rmsg << endl;
|
||
delete rionu;
|
||
|
||
exit (0);
|
||
//if (!ionu_eyefile_replace_fek ("test/performance.ionu", fek64))
|
||
// rc += testfailed ("ionu_eyefile_replace_fek", "test/performance.ionu");
|
||
//rc = EyeContainer::ReplaceMetaData (eyefile, IONU_EYE_FEK_FILE, fek64, junk);
|
||
TestEyeContainer();
|
||
exit (0);
|
||
cout << ionu_eyefile_get_status ("test/oldtest.ionu") << endl;
|
||
cout << ionu_eyefile_get_filenames ("test/oldtest.ionu");
|
||
//exit (0);
|
||
Keyring* b = new Keyring ("test/testbot-keyring.iks.device.iks");
|
||
b->Dump();
|
||
b = new Keyring ("test/testbot-keyring.iks");
|
||
b->Dump();
|
||
static const char* pkcs1_5 = "R6wk+Bv95uTd0ipk4azmDnOIrUNFuV4eB1USG4uRIcsGcZS7Zh86nBXP8XxvYjjYglYf8234IrFMccmQ5Dk8a5F2fgdLZhwW976h8zhMOgpMHsyaWKELeTdncfd1kR3yTXxRHPCGrS5uglC4WACRmtkjlpWQNs5SHTzFgKcNphtVw7n8bUj5A4h0gTURWPw+uQ7/F6+/el1K6W+4gIBxhJ+Phqws5rJZtp4RHnBFWBTAtNkRx/4XvTk472CCCnG4D5C7mzqbgBpDOKYfq0JVptw8YV9dbkjrxUg4ioNQGAq1YN3xqSqiAy2tHsImTaPtTZMH+CRA/BwCMCpiRUtU9Q==";
|
||
static const char* pkcs2_0 = "qiU6RjO7JsiuW8o9J6gerBClAGUY5fXu09JCKXbVE+3RHaG741yzvTuXOi+6ZZrL4ldBzSXvtXwBngGuKZZhQU++eUmiuZyMJeifKuqCpTrwQ3rmBpCxrTCvlXO+br64+w81apgaDySh3EyU7y1q7DyiqAgOjrhpN9zcLxX2hRjrdTtZD8LPsQ2k1eSNjx9/tDIE3BXcRIi5kngL2lT/spjiF1OULVH+AWj0hizzR+iDHOpPxbOAJDD2ckNRYb4UoLnF3ELA3jBvG82CS0oXvWc8rHroDEJX6ja7f0GCPwwiSJA1wm94M31cu1L/YZ10LJXEt+imcLYx9Ixoes3Org==";
|
||
unsigned char* pbuff;
|
||
unsigned char* back;
|
||
Key* RSA = new Key ("Auditor", "RSA auditing key", (int)strlen(BOT_private), (const unsigned char*)BOT_private, Key::RSA);
|
||
Keyring* botk = new Keyring("j", "k");
|
||
botk->AddKey (RSA);
|
||
botk->Lock (TGIkey);
|
||
botk->SaveAs ("test/bot.iks");
|
||
delete botk;
|
||
botk = new Keyring ("test/bot.iks");
|
||
botk->Unlock (TGIkey);
|
||
std::string pem;
|
||
pem.assign ((char*)botk->GetKey ("Auditor")->GetKey(), botk->GetKey ("Auditor")->GetLength());
|
||
cout << pem << endl;
|
||
|
||
char* pkk = botk->GetPubKey ("Auditor");
|
||
cout << pkk << endl;
|
||
const Key* A = botk->GetKey ("Auditor");
|
||
Key kpubkey ("CG", "public key", (int)strlen(pkk), (const unsigned char*) pkk, Key::RSA_PUBLIC);
|
||
unsigned char b64bot[1024];
|
||
size_t botbytes = sequencelogic::Base64Decode (pkcs1_5, b64bot);
|
||
cout << "decoded " << botbytes << endl;
|
||
unsigned char* bot = A->PrivateKeyDecrypt (b64bot, 256, &botbytes);
|
||
cout << "decrypted " << botbytes << endl;
|
||
botbytes = sequencelogic::Base64Decode (pkcs2_0, b64bot);
|
||
bot = A->PrivateKeyDecrypt (b64bot, 256, &botbytes);
|
||
cout << "decrypted " << botbytes << endl;
|
||
pbuff = kpubkey.PublicKeyEncrypt (BOTtgi, 32, &botbytes);
|
||
sequencelogic::Base64Encode (pbuff, 256, (char*)b64bot);
|
||
cout << (char*)b64bot << endl;
|
||
back = A->PrivateKeyDecrypt (pbuff, botbytes, &botbytes);
|
||
cout << "decrypted " << botbytes << endl;
|
||
if (memcmp (back, BOTtgi, 32) != 0)
|
||
cout << "fail " << endl;
|
||
Keyring ring ("tim", "test");
|
||
ring.GenerateRSAKey("random", "RSA keypair");
|
||
ring.GenerateRSAKey("office", "RSA keypair");
|
||
char* pk = ring.GetPubKey ("random");
|
||
Key publicK ("CG", "public key", (int)strlen(pk), (const unsigned char*) pk, Key::RSA_PUBLIC);
|
||
const Key* privateK = ring.GetKey("office");
|
||
size_t bytes = 0;
|
||
pbuff = publicK.PublicKeyEncrypt ((unsigned char*)"Howdy", 6, &bytes);
|
||
back = privateK->PrivateKeyDecrypt (pbuff, bytes, &bytes);
|
||
char b64[1024];
|
||
sequencelogic::Base64Encode (back, bytes, b64);
|
||
cout << "decrypted " << bytes << " " << b64 << endl;
|
||
//unsigned char bk[32] = {-8, -19, 27, -82, 116, 77, -97, 125, -76, 21, 15, 89, -81, 121, -11, 103, -86, -55, -55, -63, -37, 26, -112, -115, 29, -71, -98, 96, 108, 44, -12, 27};
|
||
//EyeContainer* bc = new EyeContainer("test/BCollaborators.json.ionu", bk);
|
||
//cout << bc->GetTextMessage("Collaborators");
|
||
#ifdef ddbbggrr
|
||
unsigned char buff[32];
|
||
EyeDRBG drbg ((unsigned char*)"IOnU,Bob,Bob,Bob", strlen ("IOnU,Bob,Bob,Bob"));
|
||
drbg.RandBytes (buff, 32);
|
||
char bhex[128];
|
||
sequencelogic::BinaryToHex (buff, 32, bhex);
|
||
cout << bhex << endl;
|
||
exit (0);
|
||
#endif
|
||
EyeTime now ("2014-10-28T23:13:06.174Z");
|
||
cout << now << endl;
|
||
now.SetFileTime ("t");
|
||
now.GetFileTime ("t");
|
||
cout << now << endl;
|
||
EyeContainer jj ("jjj.ionu", tgi);
|
||
cout << jj.GetLastErrorMessage() << endl;
|
||
fstream tf ("jjj");
|
||
cout << sequencelogic::GetLastErrorMessage();
|
||
|
||
EyeLog::GetInstance()->SetLogLevel (EyeLog::IONU_DEBUG);
|
||
EyeContainer::UpdateMetaData ("test/performance.ionu", ".ionumeta", "{\"modified_date\":\"2014-10-28T23:13:06.174Z\"}", junk);
|
||
EyeContainer::SynchronizeFileTime ("test/performance.ionu", junk);
|
||
//exit (0);
|
||
std::string alan ("Yo there Alan Frost, what are you up to!");
|
||
std::string frost ("Working my ass off you fool");
|
||
std::streamoff entrysize;
|
||
|
||
EyeContainer* zero = new EyeContainer("test/zero.ionu", tgi, URN, PERMS);
|
||
zero->AddMemoryFile ("stream", (unsigned char*)alan.data(), 0, "zero/stream");
|
||
zero->UpdateMetaData ("{\"entry\":\"bstream\"}");
|
||
if (zero->RenameFile ("stream", "bstream"))
|
||
cout << "success" << endl;
|
||
cout << zero->GetContentFilenames() << endl;
|
||
zero->SetStreamSize ("stream", 100);
|
||
zero->Finalize();
|
||
delete zero;
|
||
cout << EyeContainer::GetMetaData ("test/zero.ionu", ".ionumeta", junk) << endl;
|
||
//exit (1);
|
||
|
||
EyeContainer* greg = new EyeContainer("test/greg.ionu", tgi, URN, PERMS);
|
||
greg->AddMemoryFile ("stream", (unsigned char*)alan.data(), alan.size(), "test/stream");
|
||
if (greg->ExtractFile ("stream", "test"))
|
||
rc += testfailed ("greg->ExtractFile(stream)", "test");
|
||
EyeContainer* frank = new EyeContainer("test/frank.ionu", tgi, URN, PERMS);
|
||
frank->AddMemoryFile ("frank", (unsigned char*)frost.data(), frost.size(), "test/frankly");
|
||
greg->CopyEntry (frank, "frank");
|
||
greg->CopyEntry (frank, "frank");
|
||
greg->CopyEntry (frank, "fred");
|
||
if (greg->HasEntry ("stream", &entrysize))
|
||
cout << "stream " << entrysize << endl;
|
||
frank->Finalize();
|
||
delete frank;
|
||
greg->Finalize();
|
||
delete greg;
|
||
|
||
greg = new EyeContainer("test/greg.ionu", tgi);
|
||
cout << greg->GetTextMessage ("stream") << endl;
|
||
cout << greg->GetTextMessage ("frank") << endl;
|
||
cout << greg->GetMetaData() << endl;
|
||
delete greg;
|
||
|
||
greg = new EyeContainer("test/greg.ionu", tgi, URN, PERMS);
|
||
greg->AddMemoryFile (".imchat", (unsigned char*)alan.data(), alan.size(), "test/stream");
|
||
greg->Finalize();
|
||
delete greg;
|
||
greg = new EyeContainer("test/greg.ionu", tgi);
|
||
frost = greg->GetTextMessage (".imchat");
|
||
cout << frost << endl;
|
||
cout << greg->GetMetaData() << endl;
|
||
delete greg;
|
||
|
||
|
||
//rc += TestStreams();
|
||
//rc += TestEyeContainer();
|
||
const char* tk = "a0W4wBu0ZTANeEEokBlVChhHY818ztsqadHDqNrbeuo=";
|
||
unsigned char gtk[SL_AES_KEY_LEN];
|
||
sequencelogic::Base64Decode (tk, gtk);
|
||
|
||
char buffy[65536];
|
||
ionu_eyefile_get_content ("test/HTML.html.ionu", gtk, "HTML.html", (unsigned char*)buffy);
|
||
std::string kool (buffy, 100);
|
||
cout << kool << endl;
|
||
|
||
const char* ttk = "veR+rSvtWMOZlqwlL9tlZ2/n1YtGtEO8aaNjDy8paRU=";
|
||
sequencelogic::Base64Decode (ttk, gtk);
|
||
//ionu_eyefile_get_content ("test/Test.txt.ionu", gtk, "Test.txt", (unsigned char*)buffy);
|
||
//kool.assign (buffy, 100);
|
||
//cout << kool << endl;
|
||
|
||
//EyeContainer* geye = new EyeContainer ("test/PDF.pdf.ionu", gtk);
|
||
//geye->ExtractFile ("PDF.pdf");
|
||
|
||
EyeContainer* nU = new EyeContainer("test/stream.ionu", tgi, URN, PERMS);
|
||
nU->AddMemoryFile ("stream", (unsigned char*)alan.data(), alan.size(), "test/stream");
|
||
nU->Finalize();
|
||
delete nU;
|
||
nU = new EyeContainer("test/stream.ionu", tgi);
|
||
frost = nU->GetTextMessage ("stream");
|
||
cout << frost << endl;
|
||
EyeLog::GetInstance()->SetLogLevel (EyeLog::IONU_WARN);
|
||
EyeLog::GetInstance()->SetLogLevel (EyeLog::IONU_DEBUG);
|
||
|
||
#define WOW
|
||
#ifdef WOW
|
||
std::string m = ionu_eyefile_get_message (oldionu, TGIkey, ".imchat");
|
||
if (m.compare ("Yo!") == 0)
|
||
cout << m << " - old .ionu quick check passed" << endl;
|
||
else
|
||
rc += testfailed ("ionu_eyefile_get_message", oldionu);
|
||
cout << "---" << endl;
|
||
ionu_eyefile_create_with_message (yoionu, TGIkey, ".imchatty", "Yo!", 3, URN, PERMS);
|
||
cout << ionu_eyefile_get_message (yoionu, TGIkey, ".imchatty") << endl;
|
||
ionu_eyefile_rename_file (yoionu, ".imchatty", ".imchat");
|
||
cout << ionu_eyefile_get_message (yoionu, TGIkey, ".imchat") << endl;
|
||
char* modmeta = ionu_eyefile_get_meta_data (yoionu);
|
||
cout << modmeta << endl << "------" << endl;
|
||
EyeJSONObject modtest (modmeta);
|
||
if (modmeta) free (modmeta);
|
||
EyeJSONScalar* murn = (EyeJSONScalar*)modtest.GetMember ("urn");
|
||
std::string murnjson;
|
||
murn->ReplaceValue (officeURN);
|
||
murn->GetJSONString (murnjson);
|
||
murnjson = "{" + murnjson + "}";
|
||
cout << murnjson << endl << "------" << endl;
|
||
EyeContainer* eye = new EyeContainer (yoionu, TGIkey);
|
||
eye->UpdateMetaData (murnjson);
|
||
eye->Finalize();
|
||
delete eye;
|
||
m = EyeContainer::GetMetaDataClassic (yoionu);
|
||
cout << "meta = " << m << endl;
|
||
m = EyeContainer::GetPermissionsClassic (yoionu);
|
||
cout << "perm = " << m << endl;
|
||
EyeContainer::UpdateMetaData (yoionu, ".ionumeta", "{\"msg\":{\"drr\":true}}", junk);
|
||
m = EyeContainer::GetMetaDataClassic (yoionu);
|
||
cout << "meta = " << m << endl;
|
||
cout << ionu_eyefile_get_message (yoionu, TGIkey, ".imchat") << endl;
|
||
|
||
//exit (0);
|
||
murn->ReplaceValue (docURN);
|
||
modtest.GetJSONString (murnjson);
|
||
cout << murnjson << endl << "------" << endl;
|
||
ionu_eyefile_replace_meta_data (yoionu, murnjson.c_str());
|
||
m = EyeContainer::GetMetaDataClassic (yoionu);
|
||
cout << "--\nmeta = " << m << endl;
|
||
m = EyeContainer::GetPermissionsClassic (yoionu);
|
||
cout << "--\nperm = " << m << endl;
|
||
cout << "--\nmsg = " << ionu_eyefile_get_message (yoionu, TGIkey, ".imchat") << endl;
|
||
#endif
|
||
|
||
//TestP2P();
|
||
//exit (1);
|
||
|
||
// casting output of GetNumBytes to match format string
|
||
printf ("%ld test\n", long(EyeDirectory::GetNumBytes ("test")));
|
||
std::string meta;
|
||
std::string msg;
|
||
char* cmsg = NULL;
|
||
EyeBytes currency (utf8, 6);
|
||
EyeBytes utfmsg;
|
||
utfmsg.Assign (utf8, 6);
|
||
cmsg = utfmsg.GetUTF8EncodedString();
|
||
if (cmsg) {
|
||
printf ("%d bytes <%s>\n", (int)(utfmsg.GetSize()), cmsg);
|
||
delete[] cmsg;
|
||
}
|
||
utfmsg.AssignUTF8EncodedString (smiley);
|
||
cmsg = utfmsg.GetUTF8EncodedString();
|
||
if (cmsg) {
|
||
printf ("%d bytes <%s>\n", (int)(utfmsg.GetSize()), cmsg);
|
||
delete[] cmsg;
|
||
}
|
||
utfmsg.AssignUTF8EncodedString (utfeuro);
|
||
cmsg = utfmsg.GetUTF8EncodedString();
|
||
if (cmsg) {
|
||
printf ("%d bytes <%s>\n", (int)(utfmsg.GetSize()), cmsg);
|
||
delete[] cmsg;
|
||
}
|
||
utfmsg.AssignUTF8EncodedString (utfjson);
|
||
cmsg = utfmsg.GetUTF8EncodedString();
|
||
if (cmsg) {
|
||
printf ("%d bytes <%s>\n", (int)(utfmsg.GetSize()), cmsg);
|
||
delete[] cmsg;
|
||
}
|
||
|
||
ionu_derive_key (password, garbage); // Create a key (32 bytes of random binary data) for testing
|
||
|
||
// Test logging, json and other utilities
|
||
rc += TestLogging();
|
||
rc += TestRandom();
|
||
rc += TestJSON();
|
||
rc += TestUtils();
|
||
rc += TestTime();
|
||
rc += IONUCompressTests();
|
||
rc += IOnUPasswordTests();
|
||
rc += TestDB();
|
||
rc += TestDirectory();
|
||
rc += TestFileLocking();
|
||
rc += TestFileThreadLocking();
|
||
|
||
// Test the Keyring
|
||
rc += TestKeys();
|
||
rc += TestRSAKeyGeneration();
|
||
|
||
// Test the EyeContainer
|
||
EyeLog::GetInstance()->SetLogLevel (EyeLog::IONU_DEBUG);
|
||
rc += TestEyeContainer();
|
||
rc += TestMixedUpKeys();
|
||
rc += PerformanceTest();
|
||
|
||
if (rc == 0) {
|
||
printf ("All tests passed\n-------------------------------\n");
|
||
return 0;
|
||
}
|
||
else {
|
||
printf ("%d tests failed\n-------------------------------\n", rc);
|
||
return 1;
|
||
}
|
||
*/
|
||
}
|
||
|