/** @see Allocator_child() */
static struct Allocator* childAllocator(const struct Allocator* allocator,
const char* identFile,
int identLine)
{
struct CanaryAllocator_pvt* ctx = Identity_cast((struct CanaryAllocator_pvt*) allocator);
return CanaryAllocator_new(ctx->alloc->child(ctx->alloc, identFile, identLine), ctx->rand);
}
int main()
{
char out[512];
struct Allocator* alloc = CanaryAllocator_new(MallocAllocator_new(1<<20), NULL);
struct Writer* writer = ArrayWriter_new(out, 512, alloc);
struct Reader* reader = ArrayReader_new(out, 512, alloc);
testSerialize(writer, reader);
testParse(writer, reader, alloc);
Allocator_free(alloc);
}
struct CryptoAuth_Wrapper* setUp(uint8_t* myPrivateKey,
uint8_t* herPublicKey,
uint8_t* authPassword,
struct Message** resultMessage)
{
struct Allocator* allocator = CanaryAllocator_new(MallocAllocator_new(8192*2), NULL);
struct Writer* writer = FileWriter_new(stdout, allocator);
struct Log* logger = WriterLog_new(writer, allocator);
struct CryptoAuth* ca = CryptoAuth_new(allocator, myPrivateKey, eventBase, logger, NULL);
struct Interface* iface =
allocator->clone(sizeof(struct Interface), allocator, &(struct Interface) {
.sendMessage = sendMessage,
.senderContext = resultMessage
});
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};
strcpy((char*) m.bytes, "hello world");
Exports_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_always(!Bits_memcmp(expected, output, 56));
Assert_always(!Exports_decryptRndNonce(nonce, &m, secret));
Assert_always(m.length == 12 && !Bits_memcmp(m.bytes, "hello world", m.length));
}
void createNew()
{
uint8_t buff[BUFFER_SIZE];
struct Allocator* allocator = CanaryAllocator_new(BufferAllocator_new(buff, BUFFER_SIZE), NULL);
struct CryptoAuth* ca = CryptoAuth_new(allocator, privateKey, eventBase, NULL, NULL);
/*for (int i = 0; i < 32; i++) {
printf("%.2x", ca->publicKey[i]);
}*/
Assert_always(Bits_memcmp(ca->publicKey, publicKey, 32) == 0);
}
/** @return a string representing the address and port to connect to. */
static String* initAngel(int fromAngel,
int toAngel,
int corePipes[2][2],
struct PipeInterface** piOut,
struct EventBase* eventBase,
struct Log* logger,
struct Allocator* alloc,
struct Random* rand)
{
#define TO_CORE (corePipes[0][1])
#define FROM_CORE (corePipes[1][0])
#define TO_ANGEL_AS_CORE (corePipes[1][1])
#define FROM_ANGEL_AS_CORE (corePipes[0][0])
Dict core = Dict_CONST(
String_CONST("fromCore"), Int_OBJ(FROM_CORE), Dict_CONST(
String_CONST("toCore"), Int_OBJ(TO_CORE), NULL
));
Dict admin = Dict_CONST(
String_CONST("bind"), String_OBJ(String_CONST("127.0.0.1")), Dict_CONST(
String_CONST("core"), Dict_OBJ(&core), Dict_CONST(
String_CONST("pass"), String_OBJ(String_CONST("abcd")), NULL
)));
Dict message = Dict_CONST(
String_CONST("admin"), Dict_OBJ(&admin), NULL
);
struct Allocator* tempAlloc;
BufferAllocator_STACK(tempAlloc, 1024);
#define BUFFER_SZ 1023
uint8_t buff[BUFFER_SZ + 1] = {0};
struct Writer* w = ArrayWriter_new(buff, BUFFER_SZ, tempAlloc);
StandardBencSerializer_get()->serializeDictionary(w, &message);
Log_info(logger, "Writing intial configuration to angel on [%d] config: [%s]", toAngel, buff);
write(toAngel, buff, w->bytesWritten(w));
// This is angel->core data, we can throw this away.
//Waiter_getData(buff, BUFFER_SZ, fromAngel, eventBase, NULL);
//Log_info(logger, "Init message from angel to core: [%s]", buff);
Bits_memset(buff, 0, BUFFER_SZ);
struct PipeInterface* pi =
PipeInterface_new(FROM_ANGEL_AS_CORE, TO_ANGEL_AS_CORE, eventBase, logger, alloc, rand);
*piOut = pi;
Log_info(logger, "PipeInterface [%p] is now ready.", (void*)pi);
// Make sure the angel sends data to the core.
InterfaceWaiter_waitForData(&pi->generic, eventBase, alloc, NULL);
// Send response on behalf of core.
char coreToAngelResponse[128] = " PADDING "
"\xff\xff\xff\xff"
"d"
"5:error" "4:none"
"e";
char* start = strchr(coreToAngelResponse, '\xff');
struct Message m = {
.bytes = (uint8_t*) start,
.length = strlen(start),
.padding = start - coreToAngelResponse
};
pi->generic.sendMessage(&m, &pi->generic);
// This is angel->client data, it will tell us which port was bound.
Waiter_getData(buff, BUFFER_SZ, fromAngel, eventBase, NULL);
printf("Response from angel to client: [%s]\n", buff);
struct Reader* reader = ArrayReader_new(buff, BUFFER_SZ, tempAlloc);
Dict configStore;
Dict* config = &configStore;
Assert_true(!StandardBencSerializer_get()->parseDictionary(reader, tempAlloc, config));
Dict* responseAdmin = Dict_getDict(config, String_CONST("admin"));
String* bind = Dict_getString(responseAdmin, String_CONST("bind"));
Assert_true(bind);
return String_clone(bind, alloc);
}
/**
* This spawns itself as the Angel process which spawns itself again as the core process.
* The "core process" pipes all of its inputs back to the originating process
*/
struct AdminTestFramework* AdminTestFramework_setUp(int argc, char** argv)
{
if (argc > 1 && !strcmp("angel", argv[1])) {
exit(AngelInit_main(argc, argv));
}
struct Allocator* alloc = CanaryAllocator_new(MallocAllocator_new(1<<20), NULL);
struct Writer* logwriter = FileWriter_new(stdout, alloc);
Assert_always(logwriter);
struct Log* logger = WriterLog_new(logwriter, alloc);
struct EventBase* eventBase = EventBase_new(alloc);
struct Random* rand = Random_new(alloc, NULL);
int fromAngel;
int toAngel;
int corePipes[2][2];
if (Pipe_createUniPipe(corePipes[0]) || Pipe_createUniPipe(corePipes[1])) {
Except_raise(NULL, -1, "Failed to create pipes [%s]", Errno_getString());
}
spawnAngel(&fromAngel, &toAngel);
struct PipeInterface* pi;
String* addrStr =
initAngel(fromAngel, toAngel, corePipes, &pi, eventBase, logger, alloc, rand);
Log_info(logger, "Angel initialized.");
String* password = String_new("abcd", alloc);
struct Admin* admin =
Admin_new(&pi->generic, alloc, logger, eventBase, password);
// Now setup the client.
struct sockaddr_storage addr;
int addrLen = sizeof(struct sockaddr_storage);
Bits_memset(&addr, 0, sizeof(struct sockaddr_storage));
Assert_true(!evutil_parse_sockaddr_port(addrStr->bytes, (struct sockaddr*) &addr, &addrLen));
struct AdminClient* client =
AdminClient_new((uint8_t*) &addr, addrLen, password, eventBase, logger, alloc);
Assert_always(client);
return alloc->clone(sizeof(struct AdminTestFramework), alloc, &(struct AdminTestFramework) {
.admin = admin,
.client = client,
.alloc = alloc,
.eventBase = eventBase,
.logger = logger,
.addr = alloc->clone(addrLen, alloc, &addr),
.addrLen = addrLen,
.angelInterface = &pi->generic
});
}
static void sendConfToCore(struct Interface* toCoreInterface,
struct Allocator* alloc,
Dict* config,
struct Except* eh,
struct Log* logger)
{
#define CONFIG_BUFF_SIZE 1024
uint8_t buff[CONFIG_BUFF_SIZE + 32] = {0};
uint8_t* start = buff + 32;
struct Writer* writer = ArrayWriter_new(start, CONFIG_BUFF_SIZE - 33, alloc);
if (StandardBencSerializer_get()->serializeDictionary(writer, config)) {
Except_raise(eh, -1, "Failed to serialize pre-configuration for core.");
}
struct Message m = {
.bytes = start,
.length = writer->bytesWritten(writer),
.padding = 32
};
Log_keys(logger, "Sent [%d] bytes to core [%s].", m.length, m.bytes);
toCoreInterface->sendMessage(&m, toCoreInterface);
}
static void setUser(char* user, struct Log* logger, struct Except* eh)
{
struct Jmp jmp;
Jmp_try(jmp) {
Security_setUser(user, logger, &jmp.handler);
} Jmp_catch {
if (jmp.code == Security_setUser_PERMISSION) {
return;
}
Except_raise(eh, jmp.code, "%s", jmp.message);
}
}
/**
* Input:
* {
* "admin": {
* "core": "/path/to/core/binary",
* "bind": "127.0.0.1:12345",
* "pass": "******",
* "user": "******"
* }
* }
* for example:
* d5:admind4:core30:./build/admin/angel/cjdns-core4:bind15:127.0.0.1:123454:pass4:abcdee
*
* Pre-existing core mode:
* {
* "admin": {
* "core": {
* "fromCore": 12,
* "toCore": 14
* },
* "bind": "127.0.0.1:12345",
* "pass": "******",
* "user": "******"
* }
* }
*
* If "core" is a dictionary, the angel will behave as though the core is already spawned and
* it will read from the core on the file descriptor given by "fromCore" and write to the file
* given by "toCore".
*
* "user" is optional, if set the angel will setuid() that user's uid.
*/
int AngelInit_main(int argc, char** argv)
{
struct Except* eh = NULL;
int inFromClientNo;
int outToClientNo;
if (argc < 3 || (inFromClientNo = atoi(argv[2])) == 0) {
inFromClientNo = STDIN_FILENO;
}
if (argc < 4 || (outToClientNo = atoi(argv[3])) == 0) {
outToClientNo = STDOUT_FILENO;
}
struct Allocator* alloc = MallocAllocator_new(1<<21);
struct Writer* logWriter = FileWriter_new(stdout, alloc);
struct Log* logger = WriterLog_new(logWriter, alloc);
struct Random* rand = Random_new(alloc, logger, eh);
alloc = CanaryAllocator_new(alloc, rand);
struct Allocator* tempAlloc = Allocator_child(alloc);
struct EventBase* eventBase = EventBase_new(alloc);
Log_debug(logger, "Initializing angel with input [%d] and output [%d]",
inFromClientNo, outToClientNo);
Log_debug(logger, "Getting pre-configuration from client");
#define CONFIG_BUFF_SIZE 1024
uint8_t buff[CONFIG_BUFF_SIZE] = {0};
Waiter_getData(buff, CONFIG_BUFF_SIZE, inFromClientNo, eventBase, eh);
Log_debug(logger, "Finished getting pre-configuration from client");
struct Reader* reader = ArrayReader_new(buff, CONFIG_BUFF_SIZE, tempAlloc);
Dict config;
if (StandardBencSerializer_get()->parseDictionary(reader, tempAlloc, &config)) {
Except_raise(eh, -1, "Failed to parse configuration.");
}
Dict* admin = Dict_getDict(&config, String_CONST("admin"));
String* core = Dict_getString(admin, String_CONST("core"));
String* bind = Dict_getString(admin, String_CONST("bind"));
String* pass = Dict_getString(admin, String_CONST("pass"));
String* user = Dict_getString(admin, String_CONST("user"));
int toCore = -1;
int fromCore = -1;
if (!core) {
Dict* coreDict = Dict_getDict(admin, String_CONST("core"));
int64_t* toCorePtr = Dict_getInt(coreDict, String_CONST("toCore"));
int64_t* fromCorePtr = Dict_getInt(coreDict, String_CONST("fromCore"));
toCore = (toCorePtr) ? *toCorePtr : -1;
fromCore = (fromCorePtr) ? *fromCorePtr : -1;
}
if (!bind || !pass || (!core && (toCore == -1 || fromCore == -1))) {
Except_raise(eh, -1, "missing configuration params in preconfig. [%s]", buff);
}
if (core) {
Log_info(logger, "Initializing core [%s]", core->bytes);
initCore(core->bytes, &toCore, &fromCore, eh);
}
Log_debug(logger, "Sending pre-configuration to core.");
struct PipeInterface* pif =
PipeInterface_new(fromCore, toCore, eventBase, logger, alloc, rand);
struct Interface* coreIface = &pif->generic;
PipeInterface_waitUntilReady(pif);
sendConfToCore(coreIface, tempAlloc, &config, eh, logger);
struct Message* coreResponse = InterfaceWaiter_waitForData(coreIface, eventBase, tempAlloc, eh);
if (write(outToClientNo, coreResponse->bytes, coreResponse->length)) {
// Ignore the result of write() without the compiler complaining.
}
#ifdef Log_KEYS
uint8_t lastChar = coreResponse->bytes[coreResponse->length-1];
coreResponse->bytes[coreResponse->length-1] = 0;
Log_keys(logger, "Sent [%s%c] to client.", coreResponse->bytes, lastChar);
coreResponse->bytes[coreResponse->length-1] = lastChar;
#endif
if (user) {
setUser(user->bytes, logger, eh);
}
Allocator_free(tempAlloc);
Angel_start(coreIface, eventBase, logger, alloc);
return 0;
}
int main()
{
AddressCalc_addressForPublicKey(nodeCjdnsIp6, fakePubKey);
struct Allocator* alloc = CanaryAllocator_new(MallocAllocator_new(1<<20), NULL);
struct Writer* w = FileWriter_new(stdout, alloc);
struct Log* logger = WriterLog_new(w, alloc);
struct Random* rand = Random_new(alloc, NULL);
struct EventBase* eb = EventBase_new(alloc);
struct IpTunnel* ipTun = IpTunnel_new(logger, eb, alloc, rand, NULL);
IpTunnel_allowConnection(fakePubKey, fakeIp6ToGive, NULL, ipTun);
struct Message* message;
Message_STACK(message, 64, 512);
const char* requestForAddresses =
"d"
"1:q" "21:IpTunnel_getAddresses"
"4:txid" "4:abcd"
"e";
strcpy((char*)message->bytes, requestForAddresses);
message->length = strlen(requestForAddresses);
Message_shift(message, Headers_UDPHeader_SIZE);
struct Headers_UDPHeader* uh = (struct Headers_UDPHeader*) message->bytes;
uh->sourceAndDestPorts = 0;
uh->length_be = Endian_hostToBigEndian16(message->length - Headers_UDPHeader_SIZE);
uint16_t* checksum = &uh->checksum_be;
*checksum = 0;
uint32_t length = message->length;
Message_shift(message, Headers_IP6Header_SIZE);
struct Headers_IP6Header* ip = (struct Headers_IP6Header*) message->bytes;
ip->versionClassAndFlowLabel = 0;
ip->flowLabelLow_be = 0;
ip->payloadLength_be = Endian_hostToBigEndian16(length);
ip->nextHeader = 17;
ip->hopLimit = 255;
Bits_memset(ip->sourceAddr, 0, 32);
Headers_setIpVersion(ip);
Message_shift(message, IpTunnel_PacketInfoHeader_SIZE);
struct IpTunnel_PacketInfoHeader* pi = (struct IpTunnel_PacketInfoHeader*) message->bytes;
Bits_memcpyConst(pi->nodeIp6Addr, nodeCjdnsIp6, 16);
Bits_memcpyConst(pi->nodeKey, fakePubKey, 32);
*checksum = Checksum_udpIp6(ip->sourceAddr, (uint8_t*) uh, length);
ipTun->nodeInterface.receiveMessage = responseWithIpCallback;
ipTun->nodeInterface.sendMessage(message, &ipTun->nodeInterface);
Assert_always(called);
called = 0;
// Now create a message for someone else.
Message_shift(message,
Headers_UDPHeader_SIZE
+ Headers_IP6Header_SIZE
+ IpTunnel_PacketInfoHeader_SIZE);
Bits_memcpyConst(ip->sourceAddr, fakeIp6ToGive, 16);
// This can't be zero.
Bits_memset(ip->destinationAddr, 1, 16);
ipTun->tunInterface.receiveMessage = messageToTun;
ipTun->nodeInterface.sendMessage(message, &ipTun->nodeInterface);
Assert_true(called);
}
/*
* This process is started with 2 parameters, they must all be numeric in base 10.
* toAngel the pipe which is used to send data back to the angel process.
* fromAngel the pipe which is used to read incoming data from the angel.
*
* Upon initialization, this process will wait for an initial configuration to be sent to
* it and then it will send an initial response.
*/
int Core_main(int argc, char** argv)
{
struct Except* eh = NULL;
int toAngel;
int fromAngel;
if (argc != 4
|| !(toAngel = atoi(argv[2]))
|| !(fromAngel = atoi(argv[3])))
{
Except_raise(eh, -1, "This is internal to cjdns and shouldn't started manually.");
}
struct Allocator* unsafeAlloc = MallocAllocator_new(ALLOCATOR_FAILSAFE);
struct Writer* logWriter = FileWriter_new(stderr, unsafeAlloc);
struct Log* preLogger = WriterLog_new(logWriter, unsafeAlloc);
struct EventBase* eventBase = EventBase_new(unsafeAlloc);
// -------------------- Setup the Pre-Logger ---------------------- //
struct IndirectLog* indirectLogger = IndirectLog_new(unsafeAlloc);
indirectLogger->wrappedLog = preLogger;
struct Log* logger = &indirectLogger->pub;
// -------------------- Setup the PRNG ---------------------- //
struct Random* rand =
LibuvEntropyProvider_newDefaultRandom(eventBase, logger, eh, unsafeAlloc);
// -------------------- Setup Protected Allocator ---------------------- //
struct Allocator* alloc = CanaryAllocator_new(unsafeAlloc, rand);
struct Allocator* tempAlloc = Allocator_child(alloc);
// The first read inside of getInitialConfig() will begin it waiting.
struct PipeInterface* pi =
PipeInterface_new(fromAngel, toAngel, eventBase, logger, alloc, rand);
Dict* config = getInitialConfig(&pi->generic, eventBase, tempAlloc, eh);
struct Hermes* hermes = Hermes_new(&pi->generic, eventBase, logger, alloc);
String* privateKeyHex = Dict_getString(config, String_CONST("privateKey"));
Dict* adminConf = Dict_getDict(config, String_CONST("admin"));
String* pass = Dict_getString(adminConf, String_CONST("pass"));
String* bind = Dict_getString(adminConf, String_CONST("bind"));
if (!(pass && privateKeyHex && bind)) {
if (!pass) {
Except_raise(eh, -1, "Expected 'pass'");
}
if (!bind) {
Except_raise(eh, -1, "Expected 'bind'");
}
if (!privateKeyHex) {
Except_raise(eh, -1, "Expected 'privateKey'");
}
Except_raise(eh, -1, "Expected 'pass', 'privateKey' and 'bind' in configuration.");
}
Log_keys(logger, "Starting core with admin password [%s]", pass->bytes);
uint8_t privateKey[32];
if (privateKeyHex->len != 64
|| Hex_decode(privateKey, 32, (uint8_t*) privateKeyHex->bytes, 64) != 32)
{
Except_raise(eh, -1, "privateKey must be 64 bytes of hex.");
}
struct Sockaddr_storage bindAddr;
if (Sockaddr_parse(bind->bytes, &bindAddr)) {
Except_raise(eh, -1, "bind address [%s] unparsable", bind->bytes);
}
struct AddrInterface* udpAdmin =
UDPAddrInterface_new(eventBase, &bindAddr.addr, alloc, eh, logger);
struct Admin* admin = Admin_new(udpAdmin, alloc, logger, eventBase, pass);
char* boundAddr = Sockaddr_print(udpAdmin->addr, tempAlloc);
Dict adminResponse = Dict_CONST(
String_CONST("bind"), String_OBJ(String_CONST(boundAddr)), NULL
);
Dict response = Dict_CONST(
String_CONST("error"), String_OBJ(String_CONST("none")), Dict_CONST(
String_CONST("admin"), Dict_OBJ(&adminResponse), NULL
));
// This always times out because the angel doesn't respond.
Hermes_callAngel(&response, angelResponse, NULL, alloc, eh, hermes);
// --------------------- Setup the Logger --------------------- //
// the prelogger will nolonger be used.
struct Log* adminLogger = AdminLog_registerNew(admin, alloc, rand);
indirectLogger->wrappedLog = adminLogger;
logger = adminLogger;
// CryptoAuth
struct Address addr;
parsePrivateKey(privateKey, &addr, eh);
struct CryptoAuth* cryptoAuth = CryptoAuth_new(alloc, privateKey, eventBase, logger, rand);
struct SwitchCore* switchCore = SwitchCore_new(logger, alloc);
struct DHTModuleRegistry* registry = DHTModuleRegistry_new(alloc);
ReplyModule_register(registry, alloc);
// Router
struct RouterModule* router = RouterModule_register(registry,
alloc,
addr.key,
eventBase,
logger,
admin,
rand);
SerializationModule_register(registry, logger, alloc);
struct IpTunnel* ipTun = IpTunnel_new(logger, eventBase, alloc, rand, hermes);
struct Ducttape* dt = Ducttape_register(privateKey,
registry,
router,
switchCore,
eventBase,
alloc,
logger,
admin,
ipTun,
rand);
struct SwitchPinger* sp =
SwitchPinger_new(&dt->switchPingerIf, eventBase, logger, alloc);
// Interfaces.
struct InterfaceController* ifController =
DefaultInterfaceController_new(cryptoAuth,
switchCore,
router,
logger,
eventBase,
sp,
rand,
alloc);
// ------------------- Register RPC functions ----------------------- //
SwitchPinger_admin_register(sp, admin, alloc);
UDPInterface_admin_register(eventBase, alloc, logger, admin, ifController);
#ifdef HAS_ETH_INTERFACE
ETHInterface_admin_register(eventBase, alloc, logger, admin, ifController);
#endif
RouterModule_admin_register(router, admin, alloc);
AuthorizedPasswords_init(admin, cryptoAuth, alloc);
Admin_registerFunction("ping", adminPing, admin, false, NULL, admin);
Core_admin_register(addr.ip6.bytes, dt, logger, ipTun, alloc, admin, eventBase);
Security_admin_register(alloc, logger, admin);
IpTunnel_admin_register(ipTun, admin, alloc);
struct Context* ctx = Allocator_clone(alloc, (&(struct Context) {
.allocator = unsafeAlloc,
.admin = admin,
.logger = logger,
.hermes = hermes
}));
