SequenceLogic/Sleds
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
b56ef122dd
Sleds/libeye/testapi.cpp

5598 lines
238 KiB
C++
Raw Normal View History

Initial commit part 2
2025-03-13 21:28:38 +00:00
// 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;
}
*/
}
Reference in New Issue Copy Permalink