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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
|
#include "assert.hpp"
#include "../include/Database.hpp"
#include "../include/Group.hpp"
#include "../include/LocalUser.hpp"
#include "../include/Encryption.hpp"
#include "../include/Hash.hpp"
#include <vector>
#include <chrono>
#include <thread>
using namespace std;
using namespace chrono_literals;
using namespace odhtdb;
void testHash()
{
Hash hash("odhtdb", 6);
assertEquals<string>("a7b30ec8ab92de60e551b26bb8f78d315697f84dd7f5549a143477e095ec934f", hash.toString());
printf("hash of 'odhtdb' is: a7b30ec8ab92de60e551b26bb8f78d315697f84dd7f5549a143477e095ec934f\n");
}
void testSignData(LocalUser *localUser)
{
std::string publicKeyStr = localUser->getPublicKey().toString();
printf("Local user public key: %s\n", publicKeyStr.c_str());
std::string privateKeyStr = localUser->getPrivateKey().toString();
printf("Local user private key: %s\n", privateKeyStr.c_str());
string expectedUnsignedData = "hello, world!";
string signedData = localUser->getPrivateKey().sign(DataView((void*)expectedUnsignedData.data(), expectedUnsignedData.size()));
assertEquals(SIGNED_HASH_SIZE + expectedUnsignedData.size(), signedData.size());
string unsignedData = localUser->getPublicKey().unsign(DataView((void*)signedData.data(), signedData.size()));
assertEquals(expectedUnsignedData, unsignedData);
try
{
Signature::KeyPair anotherKeyPair;
anotherKeyPair.getPublicKey().unsign(DataView((void*)signedData.data(), signedData.size()));
fail("Expected unsign to fail since the data was not signed with the private key matching given public key");
}
catch (UnsignWrongKeyException &e)
{
}
catch (exception &e)
{
string errMsg = "Expected unsign to fail with UnsignWrongKeyException, fail reason: ";
errMsg += e.what();
fail(errMsg);
}
try
{
Signature::KeyPair anotherKeyPair;
anotherKeyPair.getPublicKey().unsign(DataView((void*)signedData.data(), 3));
fail("Expected unsign to fail since the (signed) data is too small to have been signed (signed hash is 64 bytes)");
}
catch (UnsignInvalidSizeException &e)
{
}
catch (exception &e)
{
string errMsg = "Expected unsign to fail with UnsignInvalidSizeException, fail reason: ";
errMsg += e.what();
fail(errMsg);
}
}
void testEncryption()
{
const char *message = "hello, world!";
const unsigned long long messageLength = 13;
Encryption encryption(DataView((void*)message, messageLength));
Decryption decryption(encryption.getCipherText(), encryption.getNonce(), encryption.getKey());
assertEquals<unsigned long long>(messageLength, decryption.getDecryptedText().size);
assertEquals(0, strncmp(message, (const char*)decryption.getDecryptedText().data, messageLength));
}
int main()
{
printf("Starting tests...\n");
LocalUser *localUser = LocalUser::create(Signature::KeyPair(), "dec05eba", nullptr);
testSignData(localUser);
testEncryption();
testHash();
// TODO: Setup local bootstrap node for tests
Database database("bootstrap.ring.cx", 4222, "storage");
auto databaseCreateResponse = database.create("adminUserName", "latenight");
DatabaseNode databaseNode(databaseCreateResponse->getNodeEncryptionKey(), databaseCreateResponse->getRequestHash());
auto adminUser = (LocalUser*)databaseCreateResponse->getNodeAdminUser();
database.addData(databaseNode, adminUser, DataView{ (void*)"hello, world!", 13 });
database.addUserToGroup(databaseNode, adminUser, localUser->getName(), localUser->getPublicKey(), adminUser->getGroups()[0]);
localUser->addToGroup(adminUser->getGroups()[0]);
database.addData(databaseNode, localUser, DataView{ (void*)"hello, aaald!", 13 });
database.commit();
database.seed(databaseCreateResponse->getRequestHash(), databaseCreateResponse->getNodeEncryptionKey());
auto start = chrono::high_resolution_clock::now();
while(chrono::high_resolution_clock::now() - start < 3s)
{
this_thread::sleep_for(10ms);
}
return 0;
}
|
