Add ADDRESS_PREFIX and ADDRESS_PREFIX_BITS compilation variables.

admin/angel/Core.c

@@ -210,7 +210,7 @@ static void initTunnel(Dict* args, void* vcontext, String* txid, struct Allocato
     struct Jmp jmp;
     Jmp_try(jmp) {
         String* desiredName = Dict_getStringC(args, "desiredTunName");
-        initTunnel2(desiredName, ctx, 8, &jmp.handler);
+        initTunnel2(desiredName, ctx, AddressCalc_ADDRESS_PREFIX_BITS, &jmp.handler);
     } Jmp_catch {
         String* error = String_printf(requestAlloc, "Failed to configure tunnel [%s]", jmp.message);
         sendResponse(error, ctx->admin, txid, requestAlloc);

crypto/AddressCalc.c

@@ -14,37 +14,33 @@
  */
 #include "crypto_hash_sha512.h"
 #include "util/Bits.h"
+#include "util/Endian.h"
 #include "crypto/AddressCalc.h"
 
 #include <stdint.h>
 #include <stdbool.h>
 
-#ifndef ADDRESS_PREFIX
-#define ADDRESS_PREFIX 0xfc
-#endif
-#ifndef ADDRESS_PREFIX_BYTES
-#define ADDRESS_PREFIX_BYTES 1
-#endif
+/* These two constants are in big endian so they can be compared
+ * immediately with a uint8_t[] containing an address.
+ */
+#define ADDRESS_PREFIX_U64 (Endian_hostToBigEndian64( \
+            ((uint64_t) AddressCalc_ADDRESS_PREFIX) << (64 - AddressCalc_ADDRESS_PREFIX_BITS)))
+#define ADDRESS_PREFIX_MASK (Endian_hostToBigEndian64( \
+            UINT64_MAX << (64 - AddressCalc_ADDRESS_PREFIX_BITS)))
+
+#include <stdio.h>
 
 bool AddressCalc_validAddress(const uint8_t address[16])
 {
-    int mask = ADDRESS_PREFIX;
-    for (int8_t i=ADDRESS_PREFIX_BYTES-1; i>=0; i--) {
-        if (address[i] != (mask & 0xff)) {
-            return false;
-        }
-        mask >>= 8;
-    }
-    return true;
+    uint64_t significant_bits = *((uint64_t*) address);
+    return (significant_bits & ADDRESS_PREFIX_MASK) == ADDRESS_PREFIX_U64;
 }
 
 void AddressCalc_makeValidAddress(uint8_t address[16])
 {
-    int mask = ADDRESS_PREFIX;
-    for (int8_t i=ADDRESS_PREFIX_BYTES-1; i>=0; i--) {
-        address[i] = mask & 0xff;
-        mask >>= 8;
-    }
+    uint64_t* significant_bits = (uint64_t*) address;
+    *significant_bits &= ~ADDRESS_PREFIX_MASK; // zero out the prefix
+    *significant_bits |= ADDRESS_PREFIX_U64; // put the new prefix
 }
 
 bool AddressCalc_addressForPublicKey(uint8_t addressOut[16], const uint8_t key[32])

crypto/AddressCalc.h

@@ -21,6 +21,27 @@ Linker_require("crypto/AddressCalc.c");
 #include <stdint.h>
 #include <stdbool.h>
 
+#ifdef ADDRESS_PREFIX
+#define AddressCalc_ADDRESS_PREFIX ADDRESS_PREFIX
+#else
+#define AddressCalc_ADDRESS_PREFIX 0xfc
+#endif
+#ifdef ADDRESS_PREFIX_BITS
+#define AddressCalc_ADDRESS_PREFIX_BITS ADDRESS_PREFIX_BITS
+#else
+#define AddressCalc_ADDRESS_PREFIX_BITS 8
+#endif
+
+#if AddressCalc_ADDRESS_PREFIX_BITS > 64
+#error "ADDRESS_PREFIX_BITS may not be > 64."
+#endif
+#if AddressCalc_ADDRESS_PREFIX_BITS <= 0
+#error "ADDRESS_PREFIX_BITS may not be <= 0."
+#endif
+#if AddressCalc_ADDRESS_PREFIX >= (1 << AddressCalc_ADDRESS_PREFIX_BITS)
+#error "ADDRESS_PREFIX may not be >= 2^ADDRESS_PREFIX_BITS."
+#endif
+
 /**
  * Check if an address is valid given the IPv6
  *

debian/do-wrapper

@@ -11,6 +11,9 @@ if [[ "${DEB_BUILD_OPTIONS}" =~ nocheck ]]; then
     export NO_TEST=1
 fi
 
+export ADDRESS_PREFIX="${DEB_ADDRESS_PREFIX}"
+export ADDRESS_PREFIX_BITS="${DEB_ADDRESS_PREFIX_BITS}"
+
 # Unset CFLAGS set by debhelper to fix a number of issues.
 # It usually contains something like this:
 # -g -O2 -fstack-protector --param=ssp-buffer-size=4 -Wformat -Wformat-security

dht/dhtcore/NodeStore.c

@@ -1612,6 +1612,8 @@ struct NodeStore* NodeStore_new(struct Address* myAddress,
 
     // Create the self node
     struct Node_Two* selfNode = Allocator_calloc(alloc, sizeof(struct Node_Two), 1);
+    Assert_true(selfNode);
+    Assert_true(myAddress);
     Bits_memcpy(&selfNode->address, myAddress, sizeof(struct Address));
     selfNode->encodingScheme = NumberCompress_defineScheme(alloc);
     selfNode->alloc = alloc;

dht/dhtcore/test/NodeStore_test.c

@@ -13,35 +13,17 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 #include "memory/MallocAllocator.h"
+#include "crypto/Key.h"
+#include "crypto/random/Random.h"
 #include "dht/Address.h"
 #include "dht/dhtcore/Node.h"
 #include "dht/dhtcore/NodeList.h"
 #include "dht/dhtcore/NodeStore.h"
 #include "switch/NumberCompress.h"
 #include "util/Assert.h"
+#include "util/Base32.h"
 #include "util/log/FileWriterLog.h"
 
-static uint8_t* MY_ADDR =
-    "v13.0000.0000.0000.0001.3c95l67xxd0juy9zjn7scz5lnjsrcum33y9ghbnqf64d6z0t7sw0.k";
-
-static uint8_t* ADDRS[] = {
-    "v13.0000.0000.0000.001f.usclqxtgkksmgwv10h8h3pltm3zy27bddb20mpsbrvjlcw4d9gl0.k",
-    "v13.0000.0000.0000.001b.03ws4vngbq56ymd14vbpd92zdfr0783t7g6u3k4dtb1kuw5m62v0.k",
-    "v13.0000.0000.0000.0019.8u2pvwuf1wmf5hwxytckbk4sbyrg3rdnqdwulbgsbmw408grm500.k",
-    "v13.0000.0000.0000.0017.bf39dq2mubq17x2lmz8cwgr839s95b6gk7dmcty22uw3dj7v5zy0.k",
-    "v13.0000.0000.0000.0015.q402jm870c215kdvf4wy2qvpt4kdrx0b4zyx2vnv2fdfprf41fk0.k",
-    "v13.0000.0000.0000.0013.6npk9pfdw09t0ldp0c9usrp8pkhttg0104849ng6j5gsz3w8q3x0.k",
-    "v13.0000.0000.0000.00b6.t9lpkc69nwpxpnusc7nlgrrjmzdcjhgf52zhhr9k69t9x6hrz5c0.k",
-    "v13.0000.0000.0000.00b2.05t007gun13qnhm5czlkjlp14lpr2v2j6f4g6bmzgbwv5mj9uy60.k",
-    "v13.0000.0000.0000.00ae.f5d1l67lb3dl7z41l1lwmh0jsptq382vsyvr999brjdjqutj5m90.k",
-    "v13.0000.0000.0000.00aa.61jw1hdru3tnwv3vfpt9vmmbvyhfxc8chd9msf1jhumq2y3h5pn0.k",
-    "v13.0000.0000.0000.00a2.684v75l5czfvgmr5qkb60xd7d9l79zxg5nyj5wmbhr8nxm7wzn20.k",
-    "v13.0000.0000.0000.009e.th3p5791z6xr24plc3487xfb9tfy4n7n51y8pbhnr9771kluhr10.k",
-    "v13.0000.0000.0000.00ba.d40x5rkb8jj5v1521j5l6wd1pu7svzrmyb2kvf1rj7ll0kuydt40.k",
-    "v13.0000.0000.0000.001d.rujhjmq178wtfxccuwp3h17uq7u7phfr1t1m1zn80855h2wngl50.k",
-    "v13.0000.0000.0000.00a6.0czm5qrryjrhc4dv9zcl148pnbur1869zufrcfw8f9b7vw132yu0.k",
-    NULL
-};
 
 static void addNode(struct NodeStore* ns, uint8_t* address, struct Allocator* alloc)
 {
@@ -50,6 +32,7 @@ static void addNode(struct NodeStore* ns, uint8_t* address, struct Allocator* al
     Assert_true(NodeStore_discoverNode(ns, addr, scheme, 0, 100));
 }
 
+
 static void checkList(struct NodeList* list,
                       uint64_t* expectedOutputs,
                       struct Log* logger,
@@ -66,13 +49,36 @@ static void checkList(struct NodeList* list,
     Assert_true(!expectedOutputs[j]);
 }
 
-static void getPeersTest(struct EventBase* base, struct Log* logger, struct Allocator* alloc)
+static void genAddress(uint8_t* addr, struct Random* rand)
+{
+    uint8_t publicKey[32];
+    uint8_t ip[16];
+    uint8_t privateKey[32];
+    Key_gen(ip, publicKey, privateKey, rand);
+    uint8_t* publicKeyBase32 = CString_strstr(addr, "X");
+    Assert_true(publicKeyBase32);
+    Base32_encode(publicKeyBase32, 53, publicKey, 32);
+    publicKeyBase32[52] = '.';
+    publicKeyBase32[53] = 'k';
+}
+
+static void getPeersTest(uint8_t* addrs[],
+                         struct EventBase* base,
+                         struct Log* logger,
+                         struct Allocator* alloc,
+                         struct Random* rand)
 {
-    struct Address* myAddr = Address_fromString(String_new(MY_ADDR, alloc), alloc);
+
+    uint8_t my_addr[] =
+        "v13.0000.0000.0000.0001.XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX.k";
+    genAddress(my_addr, rand);
+
+    struct Address* myAddr = Address_fromString(String_new(my_addr, alloc), alloc);
+    Assert_true(myAddr);
     struct NodeStore* ns = NodeStore_new(myAddr, alloc, base, logger, NULL);
     NodeStore_setFullVerify(ns, true);
-    for (int i = 0; ADDRS[i]; i++) {
-        addNode(ns, ADDRS[i], alloc);
+    for (int i = 0; addrs[i]; i++) {
+        addNode(ns, addrs[i], alloc);
     }
 
     struct NodeList* list = NodeStore_getPeers(0, 8, alloc, ns);
@@ -89,8 +95,39 @@ int main(int argc, char** argv)
     struct Allocator* alloc = MallocAllocator_new(1<<20);
     struct Log* logger = FileWriterLog_new(stdout, alloc);
     struct EventBase* base = EventBase_new(alloc);
+    struct Random* rand = Random_new(alloc, NULL, NULL);
+
+    uint8_t* addrs[] = {
+        "v13.0000.0000.0000.001f.XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX.k",
+        "v13.0000.0000.0000.001b.XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX.k",
+        "v13.0000.0000.0000.0019.XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX.k",
+        "v13.0000.0000.0000.0017.XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX.k",
+        "v13.0000.0000.0000.0015.XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX.k",
+        "v13.0000.0000.0000.0013.XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX.k",
+        "v13.0000.0000.0000.00b6.XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX.k",
+        "v13.0000.0000.0000.00b2.XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX.k",
+        "v13.0000.0000.0000.00ae.XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX.k",
+        "v13.0000.0000.0000.00aa.XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX.k",
+        "v13.0000.0000.0000.00a2.XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX.k",
+        "v13.0000.0000.0000.009e.XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX.k",
+        "v13.0000.0000.0000.00ba.XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX.k",
+        "v13.0000.0000.0000.001d.XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX.k",
+        "v13.0000.0000.0000.00a6.XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX.k",
+        NULL
+    };
+
+    // Make all addresses writeable
+    for (uint8_t** addr = addrs; *addr; addr++) {
+        char *addr_rw = Allocator_malloc(alloc, 79);
+        Bits_memcpy(addr_rw, *addr, 79);
+        *addr = addr_rw;
+    }
+
+    for (uint8_t** addr = addrs; *addr; addr++) {
+        genAddress(*addr, rand);
+    }
 
-    getPeersTest(base, logger, alloc);
+    getPeersTest(addrs, base, logger, alloc, rand);
 
     Allocator_free(alloc);
     return 0;

interface/tuntap/windows/test/TAPInterface_root_test.c

@@ -18,6 +18,7 @@ int main(int argc, char** argv)
     return 0;
 }
 #else
+#include "crypto/AddressCalc.h"
 #include "interface/tuntap/windows/NDPServer.h"
 #include "exception/Except.h"
 #include "memory/Allocator.h"
@@ -112,11 +113,11 @@ printf("init test");
     ndp->generic.receiveMessage = receiveMessage;
     ndp->generic.receiverContext = alloc;
     ndp->advertisePrefix[0] = 0xfd;
-    ndp->prefixLen = 8;
+    ndp->prefixLen = AddressCalc_ADDRESS_PREFIX_BITS;
 
     struct Sockaddr_storage ss;
     Assert_true(!Sockaddr_parse("fd00::1", &ss));
-    NetDev_addAddress(ifName, &ss.addr, 8, logger, NULL);
+    NetDev_addAddress(ifName, &ss.addr, AddressCalc_ADDRESS_PREFIX_BITS, logger, NULL);
 
     Timeout_setTimeout(fail, alloc, 10000, base, alloc);
 

node_build/make.js

@@ -91,6 +91,13 @@ Builder.configure({
         builder.config.cflags.push('-D', 'TESTING=1');
     }
 
+    if (process.env['ADDRESS_PREFIX'] != undefined) {
+        builder.config.cflags.push('-D', 'ADDRESS_PREFIX=' + process.env['ADDRESS_PREFIX']);
+    }
+    if (process.env['ADDRESS_PREFIX_BITS'] != undefined) {
+        builder.config.cflags.push('-D', 'ADDRESS_PREFIX_BITS=' + process.env['ADDRESS_PREFIX_BITS']);
+    }
+
     if (!builder.config.crossCompiling) {
         if (NO_MARCH_FLAG.indexOf(process.arch) < -1) {
             builder.config.cflags.push('-march=native');

test/Beacon_test.c

@@ -136,19 +136,17 @@ static void start(struct Allocator* alloc,
                   struct Random* rand,
                   RunTest* runTest)
 {
+    uint8_t address[16];
+    uint8_t publicKey[32];
+    uint8_t privateKeyA[32];
+    Key_gen(address, publicKey, privateKeyA, rand);
     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);
-    //"publicKey": "kmzm4w0kj9bswd5qmx74nu7kusv5pj40vcsmp781j6xxgpd59z00.k",
-    //"ipv6": "fc41:94b5:0925:7ba9:3959:11ab:a006:367a",
+        TestFramework_setUp((char*) privateKeyA, alloc, base, rand, logger);
 
+    uint8_t privateKeyB[32];
+    Key_gen(address, publicKey, privateKeyB, rand);
     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);
-    //"publicKey": "vz21tg07061s8v9mckrvgtfds7j2u5lst8cwl6nqhp81njrh5wg0.k",
-    //"ipv6": "fc1f:5b96:e1c5:625d:afde:2523:a7fa:383a",
+        TestFramework_setUp((char*) privateKeyB, alloc, base, rand, logger);
 
 
     struct TwoNodes* out = Allocator_calloc(alloc, sizeof(struct TwoNodes), 1);

tunnel/test/IpTunnel_test.c

@@ -33,9 +33,6 @@
 #include "wire/Headers.h"
 #include "wire/Ethernet.h"
 
-#define PUBKEY "f3yqyp5qpmpfgvjyvtklff40510gxuuuh52vpyzvpbhh5glyfr60.k"
-#define IPV6 "fca9:f505:c650:8723:72a8:a524:530a:25c3"
-
 struct Context
 {
     struct Allocator* alloc;
@@ -373,12 +370,13 @@ int main()
     struct Log* logger = FileWriterLog_new(stdout, alloc);
     struct Random* rand = Random_new(alloc, logger, NULL);
     struct Context* ctx = Allocator_calloc(alloc, sizeof(struct Context), 1);
+    uint8_t privateKey[32];
     Identity_set(ctx);
     ctx->alloc = alloc;
     ctx->log = logger;
     ctx->rand = rand;
     ctx->base = eb;
-    Assert_true(!Key_parse(String_CONST(PUBKEY), ctx->pubKey, ctx->ipv6));
+    Assert_true(!Key_gen(ctx->ipv6, ctx->pubKey, privateKey, rand));
 
     testAddr(ctx, "192.168.1.1", 0, 32, NULL, 0, 0);
     testAddr(ctx, "192.168.1.1", 16, 24, NULL, 0, 0);