/* vim: set expandtab ts=4 sw=4: */ /* * You may redistribute this program and/or modify it under the terms of * the GNU General Public License as published by the Free Software Foundation, * either version 3 of the License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ #include "test/BeaconFramework.h" #include "crypto/Key.h" #include "io/FileWriter.h" #include "memory/MallocAllocator.h" #include "memory/Allocator.h" #include "crypto/random/Random.h" #include "interface/Iface.h" #include "util/Base32.h" #include "util/Checksum.h" #include "util/log/WriterLog.h" #include "subnode/SubnodePathfinder.h" #include "test/TestFramework.h" #include "wire/Headers.h" #include "wire/Ethernet.h" #include "interface/tuntap/TUNMessageType.h" #include "util/Hex.h" #include "util/events/Time.h" #include "util/events/Timeout.h" #include struct TwoNodes; typedef void (RunTest)(struct TwoNodes* ctx); struct TwoNodes { struct TestFramework* nodeB; struct Iface tunB; struct TestFramework* nodeA; struct Iface tunA; int messageFrom; bool beaconsSent; struct Timeout* checkLinkageTimeout; struct Log* logger; struct EventBase* base; struct Allocator* alloc; uint64_t startTime; RunTest* runTest; Identity }; #define TUNB 2 #define TUNA 1 static Iface_DEFUN incomingTunB(struct Message* msg, struct Iface* tunB) { struct TwoNodes* tn = Identity_containerOf(tunB, struct TwoNodes, tunB); uint16_t t = Er_assert(TUNMessageType_pop(msg)); Assert_true(t == Ethernet_TYPE_IP6); Er_assert(Message_eshift(msg, -Headers_IP6Header_SIZE)); printf("Message from TUN in node B [%s]\n", msg->msgbytes); tn->messageFrom = TUNB; return NULL; } static Iface_DEFUN incomingTunA(struct Message* msg, struct Iface* tunA) { struct TwoNodes* tn = Identity_containerOf(tunA, struct TwoNodes, tunA); uint16_t t = Er_assert(TUNMessageType_pop(msg)); Assert_true(t == Ethernet_TYPE_IP6); Er_assert(Message_eshift(msg, -Headers_IP6Header_SIZE)); uint8_t buff[1024]; Hex_encode(buff, 1024, msg->msgbytes, Message_getLength(msg)); printf("Message from TUN in node A [%s] [%d] [%s]\n", msg->msgbytes, Message_getLength(msg), buff); tn->messageFrom = TUNA; return NULL; } static void notLinkedYet(struct TwoNodes* ctx) { uint64_t now = Time_currentTimeMilliseconds(); if ((now - ctx->startTime) > 5000) { Assert_failure("Failed to link in 5 seconds"); } } static void checkLinkage(void* vTwoNodes) { struct TwoNodes* ctx = Identity_check((struct TwoNodes*) vTwoNodes); if (!ctx->beaconsSent) { Log_debug(ctx->logger, "Linking A and B"); TestFramework_linkNodes(ctx->nodeB, ctx->nodeA, true); ctx->beaconsSent = true; return; } //Log_debug(ctx->logger, "Checking linkage"); if (ReachabilityCollector_peerCount(ctx->nodeA->subnodePathfinder->rc) < 1) { notLinkedYet(ctx); return; } Log_debug(ctx->logger, "A seems to be linked with B"); if (ReachabilityCollector_peerCount(ctx->nodeB->subnodePathfinder->rc) < 1) { notLinkedYet(ctx); return; } Log_debug(ctx->logger, "B seems to be linked with A"); Log_debug(ctx->logger, "\n\nSetup Complete\n\n"); Timeout_clearTimeout(ctx->checkLinkageTimeout); ctx->runTest(ctx); } static void start(struct Allocator* alloc, struct Log* logger, struct EventBase* base, struct Random* rand, RunTest* runTest, bool noiseA, bool noiseB) { #if defined(ADDRESS_PREFIX) || defined(ADDRESS_PREFIX_BITS) uint8_t address[16]; uint8_t publicKey[32]; uint8_t privateKeyA[32]; Key_gen(address, publicKey, privateKeyA, rand); struct TestFramework* a = TestFramework_setUp((char*) privateKeyA, alloc, base, rand, logger, noiseA); uint8_t privateKeyB[32]; Key_gen(address, publicKey, privateKeyB, rand); struct TestFramework* b = TestFramework_setUp((char*) privateKeyB, alloc, base, rand, logger, noiseB); #else struct TestFramework* a = TestFramework_setUp("\xad\x7e\xa3\x26\xaa\x01\x94\x0a\x25\xbc\x9e\x01\x26\x22\xdb\x69" "\x4f\xd9\xb4\x17\x7c\xf3\xf8\x91\x16\xf3\xcf\xe8\x5c\x80\xe1\x4a", alloc, base, rand, logger, noiseA); //"publicKey": "kmzm4w0kj9bswd5qmx74nu7kusv5pj40vcsmp781j6xxgpd59z00.k", //"ipv6": "fc41:94b5:0925:7ba9:3959:11ab:a006:367a", struct TestFramework* b = TestFramework_setUp("\xd8\x54\x3e\x70\xb9\xae\x7c\x41\xbc\x18\xa4\x9a\x9c\xee\xca\x9c" "\xdc\x45\x01\x96\x6b\xbd\x7e\x76\xcf\x3a\x9f\xbc\x12\xed\x8b\xb4", alloc, base, rand, logger, noiseB); //"publicKey": "vz21tg07061s8v9mckrvgtfds7j2u5lst8cwl6nqhp81njrh5wg0.k", //"ipv6": "fc1f:5b96:e1c5:625d:afde:2523:a7fa:383a", #endif struct TwoNodes* out = Allocator_calloc(alloc, sizeof(struct TwoNodes), 1); Identity_set(out); out->tunB.send = incomingTunB; out->tunA.send = incomingTunA; Iface_plumb(&out->tunB, b->tunIf); Iface_plumb(&out->tunA, a->tunIf); out->nodeB = b; out->nodeA = a; out->logger = logger; out->checkLinkageTimeout = Timeout_setInterval(checkLinkage, out, 1, base, alloc); out->base = base; out->startTime = Time_currentTimeMilliseconds(); out->runTest = runTest; out->alloc = alloc; Log_debug(a->logger, "Waiting for nodes to link asynchronously..."); } static void sendMessage(struct TwoNodes* tn, char* message, struct TestFramework* from, struct TestFramework* to) { struct Message* msg = Message_new(64, 512, from->alloc); uint8_t* b = Er_assert(Message_peakBytes(msg, 64)); CString_strcpy(b, message); Er_assert(Message_truncate(msg, CString_strlen(message) + 1)); TestFramework_craftIPHeader(msg, from->ip, to->ip); struct Iface* fromIf; if (from == tn->nodeA) { fromIf = &tn->tunA; } else if (from == tn->nodeB) { fromIf = &tn->tunB; } else { Assert_true(false); } Er_assert(TUNMessageType_push(msg, Ethernet_TYPE_IP6)); RTypes_Error_t* err = Iface_send(fromIf, msg); if (err) { Assert_failure("%s\n", Rffi_printError(err, tn->alloc)); } if (to == tn->nodeA) { Assert_true(tn->messageFrom == TUNA); } else if (to == tn->nodeB) { Assert_true(tn->messageFrom == TUNB); } else { Assert_true(false); } TestFramework_assertLastMessageUnaltered(tn->nodeA); TestFramework_assertLastMessageUnaltered(tn->nodeB); tn->messageFrom = 0; } static void runTest(struct TwoNodes* tn) { sendMessage(tn, "Hello World!", tn->nodeA, tn->nodeB); sendMessage(tn, "Hello cjdns!", tn->nodeB, tn->nodeA); sendMessage(tn, "send", tn->nodeA, tn->nodeB); sendMessage(tn, "a", tn->nodeB, tn->nodeA); sendMessage(tn, "few", tn->nodeA, tn->nodeB); sendMessage(tn, "packets", tn->nodeB, tn->nodeA); sendMessage(tn, "to", tn->nodeA, tn->nodeB); sendMessage(tn, "make", tn->nodeB, tn->nodeA); sendMessage(tn, "sure", tn->nodeA, tn->nodeB); sendMessage(tn, "the", tn->nodeB, tn->nodeA); sendMessage(tn, "cryptoauth", tn->nodeA, tn->nodeB); sendMessage(tn, "can", tn->nodeB, tn->nodeA); sendMessage(tn, "establish", tn->nodeA, tn->nodeB); Log_debug(tn->logger, "\n\nTest passed, shutting down\n\n"); Allocator_free(tn->alloc); } /** Check if nodes A and C can communicate via B without A knowing that C exists. */ int BeaconFramework_test(bool noiseA, bool noiseB) { struct Allocator* alloc = MallocAllocator_new(1<<22); struct Writer* logwriter = FileWriter_new(stdout, alloc); struct Log* logger = WriterLog_new(logwriter, alloc); struct Random* rand = Random_new(alloc, logger, NULL); struct EventBase* base = EventBase_new(alloc); start(Allocator_child(alloc), logger, base, rand, runTest, noiseA, noiseB); EventBase_beginLoop(base); Allocator_free(alloc); return 0; }