1
0

BeaconFramework.c 8.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256
  1. /* vim: set expandtab ts=4 sw=4: */
  2. /*
  3. * You may redistribute this program and/or modify it under the terms of
  4. * the GNU General Public License as published by the Free Software Foundation,
  5. * either version 3 of the License, or (at your option) any later version.
  6. *
  7. * This program is distributed in the hope that it will be useful,
  8. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  9. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  10. * GNU General Public License for more details.
  11. *
  12. * You should have received a copy of the GNU General Public License
  13. * along with this program. If not, see <https://www.gnu.org/licenses/>.
  14. */
  15. #include "test/BeaconFramework.h"
  16. #include "crypto/Key.h"
  17. #include "io/FileWriter.h"
  18. #include "memory/Allocator.h"
  19. #include "crypto/random/Random.h"
  20. #include "interface/Iface.h"
  21. #include "util/Base32.h"
  22. #include "util/Checksum.h"
  23. #include "util/log/WriterLog.h"
  24. #include "subnode/SubnodePathfinder.h"
  25. #include "test/TestFramework.h"
  26. #include "wire/Headers.h"
  27. #include "wire/Ethernet.h"
  28. #include "interface/tuntap/TUNMessageType.h"
  29. #include "util/Hex.h"
  30. #include "util/events/Time.h"
  31. #include "util/events/Timeout.h"
  32. #include <stdio.h>
  33. struct TwoNodes;
  34. typedef void (RunTest)(struct TwoNodes* ctx);
  35. struct TwoNodes
  36. {
  37. struct TestFramework* nodeB;
  38. struct Iface tunB;
  39. struct TestFramework* nodeA;
  40. struct Iface tunA;
  41. int messageFrom;
  42. bool beaconsSent;
  43. struct Timeout* checkLinkageTimeout;
  44. struct Log* logger;
  45. struct EventBase* base;
  46. struct Allocator* alloc;
  47. uint64_t startTime;
  48. RunTest* runTest;
  49. Identity
  50. };
  51. #define TUNB 2
  52. #define TUNA 1
  53. static Iface_DEFUN incomingTunB(struct Message* msg, struct Iface* tunB)
  54. {
  55. struct TwoNodes* tn = Identity_containerOf(tunB, struct TwoNodes, tunB);
  56. uint16_t t = Er_assert(TUNMessageType_pop(msg));
  57. Assert_true(t == Ethernet_TYPE_IP6);
  58. Er_assert(Message_eshift(msg, -Headers_IP6Header_SIZE));
  59. printf("Message from TUN in node B [%s]\n", msg->msgbytes);
  60. tn->messageFrom = TUNB;
  61. return NULL;
  62. }
  63. static Iface_DEFUN incomingTunA(struct Message* msg, struct Iface* tunA)
  64. {
  65. struct TwoNodes* tn = Identity_containerOf(tunA, struct TwoNodes, tunA);
  66. uint16_t t = Er_assert(TUNMessageType_pop(msg));
  67. Assert_true(t == Ethernet_TYPE_IP6);
  68. Er_assert(Message_eshift(msg, -Headers_IP6Header_SIZE));
  69. uint8_t buff[1024];
  70. Hex_encode(buff, 1024, msg->msgbytes, Message_getLength(msg));
  71. printf("Message from TUN in node A [%s] [%d] [%s]\n", msg->msgbytes, Message_getLength(msg), buff);
  72. tn->messageFrom = TUNA;
  73. return NULL;
  74. }
  75. static void notLinkedYet(struct TwoNodes* ctx)
  76. {
  77. uint64_t now = Time_currentTimeMilliseconds();
  78. if ((now - ctx->startTime) > 5000) {
  79. Assert_failure("Failed to link in 5 seconds");
  80. }
  81. }
  82. static void checkLinkage(void* vTwoNodes)
  83. {
  84. struct TwoNodes* ctx = Identity_check((struct TwoNodes*) vTwoNodes);
  85. if (!ctx->beaconsSent) {
  86. Log_debug(ctx->logger, "Linking A and B");
  87. TestFramework_linkNodes(ctx->nodeB, ctx->nodeA, true);
  88. ctx->beaconsSent = true;
  89. return;
  90. }
  91. //Log_debug(ctx->logger, "Checking linkage");
  92. if (SessionManager_handleCount(ctx->nodeA->nc->sm) < 1) {
  93. notLinkedYet(ctx);
  94. return;
  95. }
  96. Log_debug(ctx->logger, "A seems to be linked with B");
  97. if (SessionManager_handleCount(ctx->nodeA->nc->sm) < 1) {
  98. notLinkedYet(ctx);
  99. return;
  100. }
  101. Log_debug(ctx->logger, "B seems to be linked with A");
  102. Log_debug(ctx->logger, "\n\nSetup Complete\n\n");
  103. Timeout_clearTimeout(ctx->checkLinkageTimeout);
  104. ctx->runTest(ctx);
  105. }
  106. static void start(struct Allocator* alloc,
  107. struct Log* logger,
  108. struct EventBase* base,
  109. struct Random* rand,
  110. RunTest* runTest,
  111. bool noiseA,
  112. bool noiseB)
  113. {
  114. #if defined(ADDRESS_PREFIX) || defined(ADDRESS_PREFIX_BITS)
  115. uint8_t address[16];
  116. uint8_t publicKey[32];
  117. uint8_t privateKeyA[32];
  118. Key_gen(address, publicKey, privateKeyA, rand);
  119. struct TestFramework* a =
  120. TestFramework_setUp((char*) privateKeyA, alloc, base, rand, logger, noiseA);
  121. uint8_t privateKeyB[32];
  122. Key_gen(address, publicKey, privateKeyB, rand);
  123. struct TestFramework* b =
  124. TestFramework_setUp((char*) privateKeyB, alloc, base, rand, logger, noiseB);
  125. #else
  126. struct TestFramework* a =
  127. TestFramework_setUp("\xad\x7e\xa3\x26\xaa\x01\x94\x0a\x25\xbc\x9e\x01\x26\x22\xdb\x69"
  128. "\x4f\xd9\xb4\x17\x7c\xf3\xf8\x91\x16\xf3\xcf\xe8\x5c\x80\xe1\x4a",
  129. alloc, base, rand, logger, noiseA);
  130. //"publicKey": "kmzm4w0kj9bswd5qmx74nu7kusv5pj40vcsmp781j6xxgpd59z00.k",
  131. //"ipv6": "fc41:94b5:0925:7ba9:3959:11ab:a006:367a",
  132. struct TestFramework* b =
  133. TestFramework_setUp("\xd8\x54\x3e\x70\xb9\xae\x7c\x41\xbc\x18\xa4\x9a\x9c\xee\xca\x9c"
  134. "\xdc\x45\x01\x96\x6b\xbd\x7e\x76\xcf\x3a\x9f\xbc\x12\xed\x8b\xb4",
  135. alloc, base, rand, logger, noiseB);
  136. //"publicKey": "vz21tg07061s8v9mckrvgtfds7j2u5lst8cwl6nqhp81njrh5wg0.k",
  137. //"ipv6": "fc1f:5b96:e1c5:625d:afde:2523:a7fa:383a",
  138. #endif
  139. struct TwoNodes* out = Allocator_calloc(alloc, sizeof(struct TwoNodes), 1);
  140. Identity_set(out);
  141. out->tunB.send = incomingTunB;
  142. out->tunA.send = incomingTunA;
  143. Iface_plumb(&out->tunB, b->tunIf);
  144. Iface_plumb(&out->tunA, a->tunIf);
  145. out->nodeB = b;
  146. out->nodeA = a;
  147. out->logger = logger;
  148. out->checkLinkageTimeout = Timeout_setInterval(checkLinkage, out, 1, base, alloc);
  149. out->base = base;
  150. out->startTime = Time_currentTimeMilliseconds();
  151. out->runTest = runTest;
  152. out->alloc = alloc;
  153. Log_debug(a->logger, "Waiting for nodes to link asynchronously...");
  154. }
  155. static void sendMessage(struct TwoNodes* tn,
  156. char* message,
  157. struct TestFramework* from,
  158. struct TestFramework* to)
  159. {
  160. struct Message* msg = Message_new(64, 512, from->alloc);
  161. uint8_t* b = Er_assert(Message_peakBytes(msg, 64));
  162. CString_strcpy(b, message);
  163. Er_assert(Message_truncate(msg, CString_strlen(message) + 1));
  164. TestFramework_craftIPHeader(msg, from->ip, to->ip);
  165. struct Iface* fromIf;
  166. if (from == tn->nodeA) {
  167. fromIf = &tn->tunA;
  168. } else if (from == tn->nodeB) {
  169. fromIf = &tn->tunB;
  170. } else {
  171. Assert_true(false);
  172. }
  173. Er_assert(TUNMessageType_push(msg, Ethernet_TYPE_IP6));
  174. RTypes_Error_t* err = Iface_send(fromIf, msg);
  175. if (err) {
  176. Assert_failure("%s\n", Rffi_printError(err, tn->alloc));
  177. }
  178. if (to == tn->nodeA) {
  179. Assert_true(tn->messageFrom == TUNA);
  180. } else if (to == tn->nodeB) {
  181. Assert_true(tn->messageFrom == TUNB);
  182. } else {
  183. Assert_true(false);
  184. }
  185. TestFramework_assertLastMessageUnaltered(tn->nodeA);
  186. TestFramework_assertLastMessageUnaltered(tn->nodeB);
  187. tn->messageFrom = 0;
  188. }
  189. static void runTest(struct TwoNodes* tn)
  190. {
  191. sendMessage(tn, "Hello World!", tn->nodeA, tn->nodeB);
  192. sendMessage(tn, "Hello cjdns!", tn->nodeB, tn->nodeA);
  193. sendMessage(tn, "send", tn->nodeA, tn->nodeB);
  194. sendMessage(tn, "a", tn->nodeB, tn->nodeA);
  195. sendMessage(tn, "few", tn->nodeA, tn->nodeB);
  196. sendMessage(tn, "packets", tn->nodeB, tn->nodeA);
  197. sendMessage(tn, "to", tn->nodeA, tn->nodeB);
  198. sendMessage(tn, "make", tn->nodeB, tn->nodeA);
  199. sendMessage(tn, "sure", tn->nodeA, tn->nodeB);
  200. sendMessage(tn, "the", tn->nodeB, tn->nodeA);
  201. sendMessage(tn, "cryptoauth", tn->nodeA, tn->nodeB);
  202. sendMessage(tn, "can", tn->nodeB, tn->nodeA);
  203. sendMessage(tn, "establish", tn->nodeA, tn->nodeB);
  204. Log_debug(tn->logger, "\n\nTest passed, shutting down\n\n");
  205. Allocator_free(tn->alloc);
  206. }
  207. /** Check if nodes A and C can communicate via B without A knowing that C exists. */
  208. int BeaconFramework_test(bool noiseA, bool noiseB)
  209. {
  210. struct Allocator* alloc = Allocator_new(1<<22);
  211. struct Writer* logwriter = FileWriter_new(stdout, alloc);
  212. struct Log* logger = WriterLog_new(logwriter, alloc);
  213. struct Random* rand = Random_new(alloc, logger, NULL);
  214. struct EventBase* base = EventBase_new(alloc);
  215. start(Allocator_child(alloc), logger, base, rand, runTest, noiseA, noiseB);
  216. EventBase_beginLoop(base);
  217. Allocator_free(alloc);
  218. return 0;
  219. }