static void encryptRndNonceTest()
{
uint8_t buff[44];
Bits_memset(buff, 0, 44);
uint8_t nonce[24];
Bits_memset(nonce, 0, 24);
uint8_t secret[32];
Bits_memset(secret, 0, 32);
struct Message m = { .bytes=&buff[32], .length=12, .padding=32};
CString_strcpy((char*) m.bytes, "hello world");
CryptoAuth_encryptRndNonce(nonce, &m, secret);
uint8_t* expected = (uint8_t*) "1391ac5d03ba9f7099bffbb6e6c69d67ae5bd79391a5b94399b293dc";
uint8_t output[57];
Hex_encode(output, 57, m.bytes, m.length);
//printf("\n%s\n%s\n", (char*) expected, (char*) output);
Assert_true(!Bits_memcmp(expected, output, 56));
Assert_true(!CryptoAuth_decryptRndNonce(nonce, &m, secret));
Assert_true(m.length == 12 && !Bits_memcmp(m.bytes, "hello world", m.length));
}
static struct Random* evilRandom(struct Allocator* alloc, struct Log* logger)
{
struct RandomSeed* evilSeed = DeterminentRandomSeed_new(alloc);
return Random_newWithSeed(alloc, logger, evilSeed, NULL);
}
static void createNew()
{
struct Allocator* allocator = MallocAllocator_new(BUFFER_SIZE);
struct CryptoAuth* ca =
CryptoAuth_new(allocator, privateKey, eventBase, NULL, evilRandom(allocator, NULL));
/*for (int i = 0; i < 32; i++) {
printf("%.2x", ca->publicKey[i]);
}*/
Assert_true(Bits_memcmp(ca->publicKey, publicKey, 32) == 0);
Allocator_free(allocator);
}
static uint8_t receiveMessage(struct Message* message, struct Interface* iface)
{
Message_pop(message, NULL, 4, NULL);
*((struct Message**)iface->receiverContext) = message;
return Error_NONE;
}
static struct CryptoAuth_Wrapper* setUp(uint8_t* myPrivateKey,
uint8_t* herPublicKey,
uint8_t* authPassword,
struct Message** resultMessage)
{
struct Allocator* allocator = MallocAllocator_new(8192*2);
struct Writer* writer = FileWriter_new(stdout, allocator);
struct Log* logger = WriterLog_new(writer, allocator);
struct CryptoAuth* ca =
CryptoAuth_new(allocator, myPrivateKey, eventBase, logger, evilRandom(allocator, logger));
struct Interface* iface = Allocator_clone(allocator, (&(struct Interface) {
.sendMessage = sendMessage,
.senderContext = resultMessage
}));
static void testGetUsers()
{
struct Allocator* allocator = MallocAllocator_new(1<<20);
struct EventBase* base = EventBase_new(allocator);
struct CryptoAuth* ca =
CryptoAuth_new(allocator, NULL, base, NULL, evilRandom(allocator, NULL));
List* users = NULL;
users = CryptoAuth_getUsers(ca, allocator);
Assert_true(List_size(users) == 0);
CryptoAuth_addUser(String_CONST("pass1"), String_CONST("user1"), ca);
users = CryptoAuth_getUsers(ca, allocator);
Assert_true(List_size(users) == 1);
Assert_true(String_equals(String_CONST("user1"), List_getString(users,0)));
CryptoAuth_addUser(String_CONST("pass2"), String_CONST("user2"), ca);
users = CryptoAuth_getUsers(ca, allocator);
Assert_true(List_size(users) == 2);
Assert_true(String_equals(String_CONST("user2"),List_getString(users,0)));
Assert_true(String_equals(String_CONST("user1"),List_getString(users,1)));
Allocator_free(allocator);
}
static void encryptRndNonceTest()
{
uint8_t buff[44];
Bits_memset(buff, 0, 44);
uint8_t nonce[24];
Bits_memset(nonce, 0, 24);
uint8_t secret[32];
Bits_memset(secret, 0, 32);
struct Message m = { .bytes=&buff[32], .length=HELLOWORLDLEN, .padding=32};
CString_strcpy((char*) m.bytes, HELLOWORLDLOWER);
CryptoAuth_encryptRndNonce(nonce, &m, secret);
uint8_t* expected = (uint8_t*) "1391ac5d03ba9f7099bffbb6e6c69d67ae5bd79391a5b94399b293dc";
uint8_t output[57];
Hex_encode(output, 57, m.bytes, m.length);
printf("\n%s\n%s\n", (char*) expected, (char*) output);
Assert_true(!Bits_memcmp(expected, output, 56));
Assert_true(!CryptoAuth_decryptRndNonce(nonce, &m, secret));
Assert_true(m.length == HELLOWORLDLEN && !Bits_memcmp(m.bytes, HELLOWORLDLOWER, m.length));
}
static struct Random* evilRandom(struct Allocator* alloc, struct Log* logger)
{
struct RandomSeed* evilSeed = DeterminentRandomSeed_new(alloc, NULL);
return Random_newWithSeed(alloc, logger, evilSeed, NULL);
}
struct Context
{
struct Allocator* alloc;
struct CryptoAuth* ca;
struct CryptoAuth_Session* sess;
struct Log* log;
struct EventBase* base;
};
static struct Context* setUp(uint8_t* myPrivateKey,
uint8_t* herPublicKey,
uint8_t* authPassword,
struct Allocator* alloc)
{
struct Context* ctx = Allocator_calloc(alloc, sizeof(struct Context), 1);
struct Log* log = ctx->log = FileWriterLog_new(stdout, alloc);
struct EventBase* base = ctx->base = EventBase_new(alloc);
struct CryptoAuth* ca = ctx->ca =
CryptoAuth_new(alloc, myPrivateKey, base, log, evilRandom(alloc, log));
struct CryptoAuth_Session* sess = ctx->sess =
CryptoAuth_newSession(ca, alloc, herPublicKey, NULL, false, Gcc_FILE);
if (authPassword) {
CryptoAuth_setAuth(String_CONST(authPassword), NULL, sess);
}
return ctx;
}
static void testHello(uint8_t* password, uint8_t* expectedOutput)
{
Assert_true(CString_strlen((char*)expectedOutput) == 264);
struct Allocator* alloc = MallocAllocator_new(1<<20);
struct Context* ctx = setUp(NULL, HERPUBKEY, password, alloc);
struct Message* msg = Message_new(0, CryptoHeader_SIZE + 12, alloc);
Message_push(msg, HELLOWORLD, HELLOWORLDLEN, NULL);
Assert_true(!CryptoAuth_encrypt(ctx->sess, msg));
char* actual = Hex_print(msg->bytes, msg->length, alloc);
if (CString_strcmp(actual, expectedOutput)) {
Assert_failure("Test failed.\n"
"Expected %s\n"
" Got %s\n", expectedOutput, actual);
}
Allocator_free(alloc);
}
