From c6ce6b46ce65f3dd88e3a5b9598b51696635627e Mon Sep 17 00:00:00 2001 From: Adam Ierymenko Date: Fri, 21 Feb 2020 08:44:53 -0800 Subject: [PATCH] build fixes --- node/C25519.cpp | 154 ++++++++++++++++---------------- node/CertificateOfOwnership.cpp | 4 +- node/CertificateOfOwnership.hpp | 4 +- node/Credential.hpp | 7 +- node/Endpoint.hpp | 2 +- node/Hash.hpp | 6 +- node/Meter.hpp | 2 +- node/Path.hpp | 4 +- node/Peer.cpp | 5 +- node/Peer.hpp | 3 +- node/README.md | 1 - node/SelfAwareness.cpp | 2 +- node/Tests.cpp | 2 + node/Topology.hpp | 4 +- node/VL1.cpp | 8 +- 15 files changed, 102 insertions(+), 106 deletions(-) diff --git a/node/C25519.cpp b/node/C25519.cpp index a3e3c5d1b..2ec393a67 100644 --- a/node/C25519.cpp +++ b/node/C25519.cpp @@ -23,17 +23,15 @@ Derived from public domain code by D. J. Bernstein. namespace { +// -------------------------------------------------------------------------------------------------------------------- + #define crypto_uint32 uint32_t #define crypto_hash_sha512_BYTES 64 - -////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////// - typedef uint8_t u8; typedef int32_t s32; typedef int64_t limb; -static inline void fsum(limb *output, const limb *in) { +ZT_ALWAYS_INLINE void fsum(limb *output, const limb *in) { unsigned i; for (i = 0; i < 10; i += 2) { output[0+i] = output[0+i] + in[0+i]; @@ -41,21 +39,21 @@ static inline void fsum(limb *output, const limb *in) { } } -static inline void fdifference(limb *output, const limb *in) { +ZT_ALWAYS_INLINE void fdifference(limb *output, const limb *in) { unsigned i; for (i = 0; i < 10; ++i) { output[i] = in[i] - output[i]; } } -static inline void fscalar_product(limb *output, const limb *in, const limb scalar) { +ZT_ALWAYS_INLINE void fscalar_product(limb *output, const limb *in, const limb scalar) { unsigned i; for (i = 0; i < 10; ++i) { output[i] = in[i] * scalar; } } -static inline void fproduct(limb *output, const limb *in2, const limb *in) { +void fproduct(limb *output, const limb *in2, const limb *in) { output[0] = ((limb) ((s32) in2[0])) * ((s32) in[0]); output[1] = ((limb) ((s32) in2[0])) * ((s32) in[1]) + ((limb) ((s32) in2[1])) * ((s32) in[0]); @@ -158,7 +156,7 @@ static inline void fproduct(limb *output, const limb *in2, const limb *in) { output[18] = 2 * ((limb) ((s32) in2[9])) * ((s32) in[9]); } -static inline void freduce_degree(limb *output) { +void freduce_degree(limb *output) { output[8] += output[18] << 4; output[8] += output[18] << 1; output[8] += output[18]; @@ -192,7 +190,7 @@ static inline void freduce_degree(limb *output) { #error "This code only works on a two's complement system" #endif -static inline limb div_by_2_26(const limb v) +ZT_ALWAYS_INLINE limb div_by_2_26(const limb v) { /* High word of v; no shift needed. */ const uint32_t highword = (uint32_t) (((uint64_t) v) >> 32); @@ -204,7 +202,7 @@ static inline limb div_by_2_26(const limb v) return (v + roundoff) >> 26; } -static inline limb div_by_2_25(const limb v) +ZT_ALWAYS_INLINE limb div_by_2_25(const limb v) { /* High word of v; no shift needed*/ const uint32_t highword = (uint32_t) (((uint64_t) v) >> 32); @@ -216,7 +214,7 @@ static inline limb div_by_2_25(const limb v) return (v + roundoff) >> 25; } -static inline void freduce_coefficients(limb *output) { +void freduce_coefficients(limb *output) { unsigned i; output[10] = 0; @@ -259,7 +257,7 @@ static inline void freduce_coefficients(limb *output) { * bound on |output[1]| is sufficient to meet our needs. */ } -static inline void fmul(limb *output, const limb *in, const limb *in2) { +ZT_ALWAYS_INLINE void fmul(limb *output, const limb *in, const limb *in2) { limb t[19]; fproduct(t, in, in2); /* |t[i]| < 14*2^54 */ @@ -269,7 +267,7 @@ static inline void fmul(limb *output, const limb *in, const limb *in2) { memcpy(output, t, sizeof(limb) * 10); } -static inline void fsquare_inner(limb *output, const limb *in) { +ZT_ALWAYS_INLINE void fsquare_inner(limb *output, const limb *in) { output[0] = ((limb) ((s32) in[0])) * ((s32) in[0]); output[1] = 2 * ((limb) ((s32) in[0])) * ((s32) in[1]); output[2] = 2 * (((limb) ((s32) in[1])) * ((s32) in[1]) + @@ -327,7 +325,7 @@ static inline void fsquare_inner(limb *output, const limb *in) { output[18] = 2 * ((limb) ((s32) in[9])) * ((s32) in[9]); } -static inline void fsquare(limb *output, const limb *in) { +void fsquare(limb *output, const limb *in) { limb t[19]; fsquare_inner(t, in); /* |t[i]| < 14*2^54 because the largest product of two limbs will be < @@ -339,7 +337,7 @@ static inline void fsquare(limb *output, const limb *in) { memcpy(output, t, sizeof(limb) * 10); } -static inline void fexpand(limb *output, const u8 *input) { +ZT_ALWAYS_INLINE void fexpand(limb *output, const u8 *input) { #define F(n,start,shift,mask) \ output[n] = ((((limb) input[start + 0]) | \ ((limb) input[start + 1]) << 8 | \ @@ -362,7 +360,7 @@ static inline void fexpand(limb *output, const u8 *input) { #error "This code only works when >> does sign-extension on negative numbers" #endif -static inline s32 s32_eq(s32 a, s32 b) { +ZT_ALWAYS_INLINE s32 s32_eq(s32 a, s32 b) { a = ~(a ^ b); a &= a << 16; a &= a << 8; @@ -372,13 +370,13 @@ static inline s32 s32_eq(s32 a, s32 b) { return a >> 31; } -static inline s32 s32_gte(s32 a, s32 b) { +ZT_ALWAYS_INLINE s32 s32_gte(s32 a, s32 b) { a -= b; /* a >= 0 iff a >= b. */ return ~(a >> 31); } -static inline void fcontract(u8 *output, limb *input_limbs) { +ZT_ALWAYS_INLINE void fcontract(u8 *output, limb *input_limbs) { int i; int j; s32 input[10]; @@ -477,7 +475,7 @@ static inline void fcontract(u8 *output, limb *input_limbs) { #undef F } -static inline void fmonty(limb *x2, limb *z2, /* output 2Q */ +ZT_ALWAYS_INLINE void fmonty(limb *x2, limb *z2, /* output 2Q */ limb *x3, limb *z3, /* output Q + Q' */ limb *x, limb *z, /* input Q */ limb *xprime, limb *zprime, /* input Q' */ @@ -552,7 +550,7 @@ static inline void fmonty(limb *x2, limb *z2, /* output 2Q */ /* |z2|i| < 2^26 */ } -static inline void swap_conditional(limb a[19], limb b[19], limb iswap) { +ZT_ALWAYS_INLINE void swap_conditional(limb a[19], limb b[19], limb iswap) { unsigned i; const s32 swap = (s32) -iswap; @@ -563,7 +561,7 @@ static inline void swap_conditional(limb a[19], limb b[19], limb iswap) { } } -static inline void cmult(limb *resultx, limb *resultz, const u8 *n, const limb *q) { +ZT_ALWAYS_INLINE void cmult(limb *resultx, limb *resultz, const u8 *n, const limb *q) { limb a[19] = {0}, b[19] = {1}, c[19] = {1}, d[19] = {0}; limb *nqpqx = a, *nqpqz = b, *nqx = c, *nqz = d, *t; limb e[19] = {0}, f[19] = {1}, g[19] = {0}, h[19] = {1}; @@ -609,7 +607,7 @@ static inline void cmult(limb *resultx, limb *resultz, const u8 *n, const limb * memcpy(resultz, nqz, sizeof(limb) * 10); } -static inline void crecip(limb *out, const limb *z) { +ZT_ALWAYS_INLINE void crecip(limb *out, const limb *z) { limb z2[10]; limb z9[10]; limb z11[10]; @@ -675,7 +673,7 @@ static inline void crecip(limb *out, const limb *z) { /* 2^255 - 21 */ fmul(out,t1,z11); } -static inline void crypto_scalarmult(u8 *mypublic, const u8 *secret, const u8 *basepoint) { +void crypto_scalarmult(u8 *mypublic, const u8 *secret, const u8 *basepoint) { limb bp[10], x[10], z[11], zmone[10]; uint8_t e[32]; int i; @@ -693,10 +691,9 @@ static inline void crypto_scalarmult(u8 *mypublic, const u8 *secret, const u8 *b } static const unsigned char base[32] = {9}; -static inline void crypto_scalarmult_base(unsigned char *q,const unsigned char *n) { crypto_scalarmult(q,n,base); } +ZT_ALWAYS_INLINE void crypto_scalarmult_base(unsigned char *q,const unsigned char *n) { crypto_scalarmult(q,n,base); } -////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////// +// -------------------------------------------------------------------------------------------------------------------- // Ed25519 ref from: http://bench.cr.yp.to/supercop.html @@ -749,9 +746,9 @@ typedef struct fe25519 y; } ge25519_aff; -static inline void fe25519_sub(fe25519 *r, const fe25519 *x, const fe25519 *y); +void fe25519_sub(fe25519 *r, const fe25519 *x, const fe25519 *y); -static inline crypto_uint32 equal(crypto_uint32 a,crypto_uint32 b) /* 16-bit inputs */ +ZT_ALWAYS_INLINE crypto_uint32 equal(crypto_uint32 a,crypto_uint32 b) /* 16-bit inputs */ { crypto_uint32 x = a ^ b; /* 0: yes; 1..65535: no */ x -= 1; /* 4294967295: yes; 0..65534: no */ @@ -759,7 +756,7 @@ static inline crypto_uint32 equal(crypto_uint32 a,crypto_uint32 b) /* 16-bit inp return x; } -static inline crypto_uint32 ge(crypto_uint32 a,crypto_uint32 b) /* 16-bit inputs */ +ZT_ALWAYS_INLINE crypto_uint32 ge(crypto_uint32 a,crypto_uint32 b) /* 16-bit inputs */ { unsigned int x = a; x -= (unsigned int) b; /* 0..65535: yes; 4294901761..4294967295: no */ @@ -768,10 +765,10 @@ static inline crypto_uint32 ge(crypto_uint32 a,crypto_uint32 b) /* 16-bit inputs return x; } -static inline crypto_uint32 times19(crypto_uint32 a) { return (a << 4) + (a << 1) + a; } -static inline crypto_uint32 times38(crypto_uint32 a) { return (a << 5) + (a << 2) + (a << 1); } +ZT_ALWAYS_INLINE crypto_uint32 times19(crypto_uint32 a) { return (a << 4) + (a << 1) + a; } +ZT_ALWAYS_INLINE crypto_uint32 times38(crypto_uint32 a) { return (a << 5) + (a << 2) + (a << 1); } -static inline void reduce_add_sub(fe25519 *r) +ZT_ALWAYS_INLINE void reduce_add_sub(fe25519 *r) { int i,rep; for(rep=0;rep<4;rep++) @@ -789,7 +786,7 @@ static inline void reduce_add_sub(fe25519 *r) } } -static inline void reduce_mul(fe25519 *r) +ZT_ALWAYS_INLINE void reduce_mul(fe25519 *r) { int i,rep; for(rep=0;rep<2;rep++) @@ -807,7 +804,7 @@ static inline void reduce_mul(fe25519 *r) } } -static inline void fe25519_freeze(fe25519 *r) +ZT_ALWAYS_INLINE void fe25519_freeze(fe25519 *r) { int i; crypto_uint32 mm = equal(r->v[31],127); @@ -823,14 +820,14 @@ static inline void fe25519_freeze(fe25519 *r) r->v[0] -= mm&237; } -static inline void fe25519_unpack(fe25519 *r, const unsigned char x[32]) +ZT_ALWAYS_INLINE void fe25519_unpack(fe25519 *r, const unsigned char x[32]) { int i; for(i=0;i<32;i++) r->v[i] = x[i]; r->v[31] &= 127; } -static inline void fe25519_pack(unsigned char r[32], const fe25519 *x) +ZT_ALWAYS_INLINE void fe25519_pack(unsigned char r[32], const fe25519 *x) { int i; fe25519 y = *x; @@ -839,7 +836,7 @@ static inline void fe25519_pack(unsigned char r[32], const fe25519 *x) r[i] = y.v[i]; } -static inline int fe25519_iseq_vartime(const fe25519 *x, const fe25519 *y) +int fe25519_iseq_vartime(const fe25519 *x, const fe25519 *y) { int i; fe25519 t1 = *x; @@ -851,7 +848,7 @@ static inline int fe25519_iseq_vartime(const fe25519 *x, const fe25519 *y) return 1; } -static inline void fe25519_cmov(fe25519 *r, const fe25519 *x, unsigned char b) +ZT_ALWAYS_INLINE void fe25519_cmov(fe25519 *r, const fe25519 *x, unsigned char b) { int i; crypto_uint32 mask = b; @@ -859,27 +856,27 @@ static inline void fe25519_cmov(fe25519 *r, const fe25519 *x, unsigned char b) for(i=0;i<32;i++) r->v[i] ^= mask & (x->v[i] ^ r->v[i]); } -static inline unsigned char fe25519_getparity(const fe25519 *x) +ZT_ALWAYS_INLINE unsigned char fe25519_getparity(const fe25519 *x) { fe25519 t = *x; fe25519_freeze(&t); return t.v[0] & 1; } -static inline void fe25519_setone(fe25519 *r) +ZT_ALWAYS_INLINE void fe25519_setone(fe25519 *r) { int i; r->v[0] = 1; for(i=1;i<32;i++) r->v[i]=0; } -static inline void fe25519_setzero(fe25519 *r) +ZT_ALWAYS_INLINE void fe25519_setzero(fe25519 *r) { int i; for(i=0;i<32;i++) r->v[i]=0; } -static inline void fe25519_neg(fe25519 *r, const fe25519 *x) +void fe25519_neg(fe25519 *r, const fe25519 *x) { fe25519 t; int i; @@ -888,14 +885,14 @@ static inline void fe25519_neg(fe25519 *r, const fe25519 *x) fe25519_sub(r, r, &t); } -static inline void fe25519_add(fe25519 *r, const fe25519 *x, const fe25519 *y) +void fe25519_add(fe25519 *r, const fe25519 *x, const fe25519 *y) { int i; for(i=0;i<32;i++) r->v[i] = x->v[i] + y->v[i]; reduce_add_sub(r); } -static inline void fe25519_sub(fe25519 *r, const fe25519 *x, const fe25519 *y) +void fe25519_sub(fe25519 *r, const fe25519 *x, const fe25519 *y) { int i; crypto_uint32 t[32]; @@ -906,7 +903,7 @@ static inline void fe25519_sub(fe25519 *r, const fe25519 *x, const fe25519 *y) reduce_add_sub(r); } -static inline void fe25519_mul(fe25519 *r, const fe25519 *x, const fe25519 *y) +void fe25519_mul(fe25519 *r, const fe25519 *x, const fe25519 *y) { int i,j; crypto_uint32 t[63]; @@ -923,9 +920,9 @@ static inline void fe25519_mul(fe25519 *r, const fe25519 *x, const fe25519 *y) reduce_mul(r); } -static inline void fe25519_square(fe25519 *r, const fe25519 *x) { fe25519_mul(r, x, x); } +ZT_ALWAYS_INLINE void fe25519_square(fe25519 *r, const fe25519 *x) { fe25519_mul(r, x, x); } -static inline void fe25519_invert(fe25519 *r, const fe25519 *x) +void fe25519_invert(fe25519 *r, const fe25519 *x) { fe25519 z2; fe25519 z9; @@ -992,7 +989,7 @@ static inline void fe25519_invert(fe25519 *r, const fe25519 *x) /* 2^255 - 21 */ fe25519_mul(r,&t1,&z11); } -static inline void fe25519_pow2523(fe25519 *r, const fe25519 *x) +void fe25519_pow2523(fe25519 *r, const fe25519 *x) { fe25519 z2; fe25519 z9; @@ -1046,10 +1043,10 @@ static inline void fe25519_pow2523(fe25519 *r, const fe25519 *x) /* 2^252 - 3 */ fe25519_mul(r,&t,x); } -static const crypto_uint32 m[32] = {0xED, 0xD3, 0xF5, 0x5C, 0x1A, 0x63, 0x12, 0x58, 0xD6, 0x9C, 0xF7, 0xA2, 0xDE, 0xF9, 0xDE, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10}; -static const crypto_uint32 mu[33] = {0x1B, 0x13, 0x2C, 0x0A, 0xA3, 0xE5, 0x9C, 0xED, 0xA7, 0x29, 0x63, 0x08, 0x5D, 0x21, 0x06, 0x21, 0xEB, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F}; +const crypto_uint32 m[32] = {0xED, 0xD3, 0xF5, 0x5C, 0x1A, 0x63, 0x12, 0x58, 0xD6, 0x9C, 0xF7, 0xA2, 0xDE, 0xF9, 0xDE, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10}; +const crypto_uint32 mu[33] = {0x1B, 0x13, 0x2C, 0x0A, 0xA3, 0xE5, 0x9C, 0xED, 0xA7, 0x29, 0x63, 0x08, 0x5D, 0x21, 0x06, 0x21, 0xEB, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F}; -static inline crypto_uint32 lt(crypto_uint32 a,crypto_uint32 b) /* 16-bit inputs */ +ZT_ALWAYS_INLINE crypto_uint32 lt(crypto_uint32 a,crypto_uint32 b) /* 16-bit inputs */ { unsigned int x = a; x -= (unsigned int) b; /* 0..65535: no; 4294901761..4294967295: yes */ @@ -1057,7 +1054,7 @@ static inline crypto_uint32 lt(crypto_uint32 a,crypto_uint32 b) /* 16-bit inputs return x; } -static inline void reduce_add_sub(sc25519 *r) +oid reduce_add_sub(sc25519 *r) { crypto_uint32 pb = 0; crypto_uint32 b; @@ -1077,7 +1074,7 @@ static inline void reduce_add_sub(sc25519 *r) r->v[i] ^= mask & (r->v[i] ^ t[i]); } -static inline void barrett_reduce(sc25519 *r, const crypto_uint32 x[64]) +void barrett_reduce(sc25519 *r, const crypto_uint32 x[64]) { /* See HAC, Alg. 14.42 */ int i,j; @@ -1119,7 +1116,7 @@ static inline void barrett_reduce(sc25519 *r, const crypto_uint32 x[64]) reduce_add_sub(r); } -static inline void sc25519_from32bytes(sc25519 *r, const unsigned char x[32]) +ZT_ALWAYS_INLINE void sc25519_from32bytes(sc25519 *r, const unsigned char x[32]) { int i; crypto_uint32 t[64]; @@ -1128,7 +1125,7 @@ static inline void sc25519_from32bytes(sc25519 *r, const unsigned char x[32]) barrett_reduce(r, t); } -static inline void sc25519_from64bytes(sc25519 *r, const unsigned char x[64]) +ZT_ALWAYS_INLINE void sc25519_from64bytes(sc25519 *r, const unsigned char x[64]) { int i; crypto_uint32 t[64]; @@ -1136,13 +1133,13 @@ static inline void sc25519_from64bytes(sc25519 *r, const unsigned char x[64]) barrett_reduce(r, t); } -static inline void sc25519_to32bytes(unsigned char r[32], const sc25519 *x) +ZT_ALWAYS_INLINE void sc25519_to32bytes(unsigned char r[32], const sc25519 *x) { int i; for(i=0;i<32;i++) r[i] = x->v[i]; } -static inline void sc25519_add(sc25519 *r, const sc25519 *x, const sc25519 *y) +ZT_ALWAYS_INLINE void sc25519_add(sc25519 *r, const sc25519 *x, const sc25519 *y) { int i; for(i=0;i<32;i++) r->v[i] = x->v[i] + y->v[i]; @@ -1154,7 +1151,7 @@ static inline void sc25519_add(sc25519 *r, const sc25519 *x, const sc25519 *y) reduce_add_sub(r); } -static inline void sc25519_mul(sc25519 *r, const sc25519 *x, const sc25519 *y) +void sc25519_mul(sc25519 *r, const sc25519 *x, const sc25519 *y) { int i,j; crypto_uint32 t[64]; @@ -1173,7 +1170,7 @@ static inline void sc25519_mul(sc25519 *r, const sc25519 *x, const sc25519 *y) barrett_reduce(r, t); } -static inline void sc25519_window3(signed char r[85], const sc25519 *s) +void sc25519_window3(signed char r[85], const sc25519 *s) { char carry; int i; @@ -1210,7 +1207,7 @@ static inline void sc25519_window3(signed char r[85], const sc25519 *s) r[84] += carry; } -static inline void sc25519_2interleave2(unsigned char r[127], const sc25519 *s1, const sc25519 *s2) +ZT_ALWAYS_INLINE void sc25519_2interleave2(unsigned char r[127], const sc25519 *s1, const sc25519 *s2) { int i; for(i=0;i<31;i++) @@ -2099,27 +2096,27 @@ static const ge25519_aff ge25519_base_multiples_affine[425] = { {{0x69, 0x3e, 0x47, 0x97, 0x2c, 0xaf, 0x52, 0x7c, 0x78, 0x83, 0xad, 0x1b, 0x39, 0x82, 0x2f, 0x02, 0x6f, 0x47, 0xdb, 0x2a, 0xb0, 0xe1, 0x91, 0x99, 0x55, 0xb8, 0x99, 0x3a, 0xa0, 0x44, 0x11, 0x51}}} }; -static inline void p1p1_to_p2(ge25519_p2 *r, const ge25519_p1p1 *p) +ZT_ALWAYS_INLINE void p1p1_to_p2(ge25519_p2 *r, const ge25519_p1p1 *p) { fe25519_mul(&r->x, &p->x, &p->t); fe25519_mul(&r->y, &p->y, &p->z); fe25519_mul(&r->z, &p->z, &p->t); } -static inline void p1p1_to_p2_2(ge25519_p3 *r, const ge25519_p1p1 *p) +ZT_ALWAYS_INLINE void p1p1_to_p2_2(ge25519_p3 *r, const ge25519_p1p1 *p) { fe25519_mul(&r->x, &p->x, &p->t); fe25519_mul(&r->y, &p->y, &p->z); fe25519_mul(&r->z, &p->z, &p->t); } -static inline void p1p1_to_p3(ge25519_p3 *r, const ge25519_p1p1 *p) +ZT_ALWAYS_INLINE void p1p1_to_p3(ge25519_p3 *r, const ge25519_p1p1 *p) { p1p1_to_p2_2(r, p); fe25519_mul(&r->t, &p->x, &p->y); } -static inline void ge25519_mixadd2(ge25519_p3 *r, const ge25519_aff *q) +ZT_ALWAYS_INLINE void ge25519_mixadd2(ge25519_p3 *r, const ge25519_aff *q) { fe25519 a,b,t1,t2,c,d,e,f,g,h,qt; fe25519_mul(&qt, &q->x, &q->y); @@ -2142,7 +2139,7 @@ static inline void ge25519_mixadd2(ge25519_p3 *r, const ge25519_aff *q) fe25519_mul(&r->t, &e, &h); } -static inline void add_p1p1(ge25519_p1p1 *r, const ge25519_p3 *p, const ge25519_p3 *q) +ZT_ALWAYS_INLINE void add_p1p1(ge25519_p1p1 *r, const ge25519_p3 *p, const ge25519_p3 *q) { fe25519 a, b, c, d, t; @@ -2163,7 +2160,7 @@ static inline void add_p1p1(ge25519_p1p1 *r, const ge25519_p3 *p, const ge25519_ } /* See http://www.hyperelliptic.org/EFD/g1p/auto-twisted-extended-1.html#doubling-dbl-2008-hwcd */ -static inline void dbl_p1p1(ge25519_p1p1 *r, const ge25519_p2 *p) +ZT_ALWAYS_INLINE void dbl_p1p1(ge25519_p1p1 *r, const ge25519_p2 *p) { fe25519 a,b,c,d; fe25519_square(&a, &p->x); @@ -2182,13 +2179,13 @@ static inline void dbl_p1p1(ge25519_p1p1 *r, const ge25519_p2 *p) } /* Constant-time version of: if(b) r = p */ -static inline void cmov_aff(ge25519_aff *r, const ge25519_aff *p, unsigned char b) +ZT_ALWAYS_INLINE void cmov_aff(ge25519_aff *r, const ge25519_aff *p, unsigned char b) { fe25519_cmov(&r->x, &p->x, b); fe25519_cmov(&r->y, &p->y, b); } -static inline unsigned char equal(signed char b,signed char c) +ZT_ALWAYS_INLINE unsigned char equal(signed char b,signed char c) { unsigned char ub = b; unsigned char uc = c; @@ -2199,14 +2196,14 @@ static inline unsigned char equal(signed char b,signed char c) return (unsigned char)y; } -static inline unsigned char negative(signed char b) +ZT_ALWAYS_INLINE unsigned char negative(signed char b) { unsigned long long x = b; /* 18446744073709551361..18446744073709551615: yes; 0..255: no */ x >>= 63; /* 1: yes; 0: no */ return (unsigned char)x; } -static inline void choose_t(ge25519_aff *t, unsigned long long pos, signed char b) +ZT_ALWAYS_INLINE void choose_t(ge25519_aff *t, unsigned long long pos, signed char b) { /* constant time */ fe25519 v; @@ -2219,7 +2216,7 @@ static inline void choose_t(ge25519_aff *t, unsigned long long pos, signed char fe25519_cmov(&t->x, &v, negative(b)); } -static inline void setneutral(ge25519 *r) +ZT_ALWAYS_INLINE void setneutral(ge25519 *r) { fe25519_setzero(&r->x); fe25519_setone(&r->y); @@ -2228,7 +2225,7 @@ static inline void setneutral(ge25519 *r) } /* return 0 on success, -1 otherwise */ -static inline int ge25519_unpackneg_vartime(ge25519_p3 *r, const unsigned char p[32]) +int ge25519_unpackneg_vartime(ge25519_p3 *r, const unsigned char p[32]) { unsigned char par; fe25519 t, chk, num, den, den2, den4, den6; @@ -2275,7 +2272,7 @@ static inline int ge25519_unpackneg_vartime(ge25519_p3 *r, const unsigned char p return 0; } -static inline void ge25519_pack(unsigned char r[32], const ge25519_p3 *p) +ZT_ALWAYS_INLINE void ge25519_pack(unsigned char r[32], const ge25519_p3 *p) { fe25519 tx, ty, zi; fe25519_invert(&zi, &p->z); @@ -2286,7 +2283,7 @@ static inline void ge25519_pack(unsigned char r[32], const ge25519_p3 *p) } /* computes [s1]p1 + [s2]p2 */ -static inline void ge25519_double_scalarmult_vartime(ge25519_p3 *r, const ge25519_p3 *p1, const sc25519 *s1, const ge25519_p3 *p2, const sc25519 *s2) +void ge25519_double_scalarmult_vartime(ge25519_p3 *r, const ge25519_p3 *p1, const sc25519 *s1, const ge25519_p3 *p2, const sc25519 *s2) { ge25519_p1p1 tp1p1; ge25519_p3 pre[16]; @@ -2331,7 +2328,7 @@ static inline void ge25519_double_scalarmult_vartime(ge25519_p3 *r, const ge2551 } } -static inline void ge25519_scalarmult_base(ge25519_p3 *r, const sc25519 *s) +ZT_ALWAYS_INLINE void ge25519_scalarmult_base(ge25519_p3 *r, const sc25519 *s) { signed char b[85]; int i; @@ -2348,7 +2345,7 @@ static inline void ge25519_scalarmult_base(ge25519_p3 *r, const sc25519 *s) } } -static inline void get_hram(unsigned char *hram, const unsigned char *sm, const unsigned char *pk, unsigned char *playground, unsigned long long smlen) +ZT_ALWAYS_INLINE void get_hram(unsigned char *hram, const unsigned char *sm, const unsigned char *pk, unsigned char *playground, unsigned long long smlen) { unsigned long long i; @@ -2359,8 +2356,7 @@ static inline void get_hram(unsigned char *hram, const unsigned char *sm, const ZeroTier::SHA512(hram,playground,(unsigned int)smlen); } -////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////////////////////////////////////////// +// -------------------------------------------------------------------------------------------------------------------- } // anonymous namespace diff --git a/node/CertificateOfOwnership.cpp b/node/CertificateOfOwnership.cpp index c183eda8d..d7e22f524 100644 --- a/node/CertificateOfOwnership.cpp +++ b/node/CertificateOfOwnership.cpp @@ -18,11 +18,11 @@ namespace ZeroTier { void CertificateOfOwnership::addThing(const InetAddress &ip) { if (_thingCount >= ZT_CERTIFICATEOFOWNERSHIP_MAX_THINGS) return; - if (ip.ss_family == AF_INET) { + if (ip.family() == AF_INET) { _thingTypes[_thingCount] = THING_IPV4_ADDRESS; memcpy(_thingValues[_thingCount],&(reinterpret_cast(&ip)->sin_addr.s_addr),4); ++_thingCount; - } else if (ip.ss_family == AF_INET6) { + } else if (ip.family() == AF_INET6) { _thingTypes[_thingCount] = THING_IPV6_ADDRESS; memcpy(_thingValues[_thingCount],reinterpret_cast(&ip)->sin6_addr.s6_addr,16); ++_thingCount; diff --git a/node/CertificateOfOwnership.hpp b/node/CertificateOfOwnership.hpp index a516b37a4..192104d17 100644 --- a/node/CertificateOfOwnership.hpp +++ b/node/CertificateOfOwnership.hpp @@ -85,9 +85,9 @@ public: ZT_ALWAYS_INLINE bool owns(const InetAddress &ip) const noexcept { - if (ip.ss_family == AF_INET) + if (ip.family() == AF_INET) return this->_owns(THING_IPV4_ADDRESS,&(reinterpret_cast(&ip)->sin_addr.s_addr),4); - if (ip.ss_family == AF_INET6) + if (ip.family() == AF_INET6) return this->_owns(THING_IPV6_ADDRESS,reinterpret_cast(&ip)->sin6_addr.s6_addr,16); return false; } diff --git a/node/Credential.hpp b/node/Credential.hpp index fa6c820d0..aeea01787 100644 --- a/node/Credential.hpp +++ b/node/Credential.hpp @@ -14,18 +14,17 @@ #ifndef ZT_CREDENTIAL_HPP #define ZT_CREDENTIAL_HPP +#include "Constants.hpp" +#include "TriviallyCopyable.hpp" + #include #include #include - #include #include #include #include -#include "Constants.hpp" -#include "TriviallyCopyable.hpp" - namespace ZeroTier { class Capability; diff --git a/node/Endpoint.hpp b/node/Endpoint.hpp index ec7266c5a..fc0c1db54 100644 --- a/node/Endpoint.hpp +++ b/node/Endpoint.hpp @@ -59,7 +59,7 @@ public: explicit ZT_ALWAYS_INLINE Endpoint(const InetAddress &sa) { - switch (sa.ss_family) { + switch (sa.family()) { case AF_INET: _t = TYPE_INETADDR_V4; break; diff --git a/node/Hash.hpp b/node/Hash.hpp index 1bbe4afcb..045f490a2 100644 --- a/node/Hash.hpp +++ b/node/Hash.hpp @@ -47,7 +47,7 @@ public: ZT_ALWAYS_INLINE void zero() noexcept { - for(int i=0;i<(BITS / sizeof(unsigned long));++i) + for(int i=0;i<(BITS / (sizeof(unsigned long) * 8));++i) _h[i] = 0; } @@ -63,7 +63,7 @@ public: ZT_ALWAYS_INLINE operator bool() const noexcept { - for(int i=0;i<(BITS / sizeof(unsigned long));++i) { + for(int i=0;i<(BITS / (sizeof(unsigned long) * 8));++i) { if (_h[i] != 0) return true; } @@ -78,7 +78,7 @@ public: ZT_ALWAYS_INLINE bool operator>=(const Hash &h) const noexcept { return memcmp(_h,h._h,BITS / 8) >= 0; } private: - unsigned long _h[BITS / sizeof(unsigned long)]; + unsigned long _h[BITS / (sizeof(unsigned long) * 8)]; }; } // namespace ZeroTier diff --git a/node/Meter.hpp b/node/Meter.hpp index b96f00b00..49db8328b 100644 --- a/node/Meter.hpp +++ b/node/Meter.hpp @@ -43,7 +43,7 @@ public: * * @param now Start time */ - ZT_ALWAYS_INLINE Meter(const int64_t now) noexcept {} + ZT_ALWAYS_INLINE Meter() noexcept {} /** * Add a measurement diff --git a/node/Path.hpp b/node/Path.hpp index 77a33f16f..b22943459 100644 --- a/node/Path.hpp +++ b/node/Path.hpp @@ -119,10 +119,10 @@ public: ZT_ALWAYS_INLINE int64_t lastOut() const noexcept { return _lastOut.load(); } private: - int64_t _localSocket; + const int64_t _localSocket; std::atomic _lastIn; std::atomic _lastOut; - InetAddress _addr; + const InetAddress _addr; Meter<> _inMeter; Meter<> _outMeter; diff --git a/node/Peer.cpp b/node/Peer.cpp index 53e4463d0..cf4d14d3c 100644 --- a/node/Peer.cpp +++ b/node/Peer.cpp @@ -231,7 +231,7 @@ unsigned int Peer::sendHELLO(void *tPtr,const int64_t localSocket,const InetAddr #endif } -void Peer::sendNOP(void *tPtr,const int64_t localSocket,const InetAddress &atAddress,int64_t now) +unsigned int Peer::sendNOP(void *tPtr,const int64_t localSocket,const InetAddress &atAddress,int64_t now) { Buf outp; Protocol::Header &ph = outp.as(); @@ -242,6 +242,7 @@ void Peer::sendNOP(void *tPtr,const int64_t localSocket,const InetAddress &atAdd ph.verb = Protocol::VERB_NOP; Protocol::armor(outp,sizeof(Protocol::Header),_key,this->cipher()); RR->node->putPacket(tPtr,localSocket,atAddress,outp.unsafeData,sizeof(Protocol::Header)); + return sizeof(Protocol::Header); } void Peer::ping(void *tPtr,int64_t now,const bool pingAllAddressTypes) @@ -375,7 +376,7 @@ void Peer::contact(void *tPtr,const Endpoint &ep,const int64_t now,const bool bf // If the peer indicates that they may be behind a symmetric NAT and there are no // living direct paths, try a few more aggressive things. - if ((phyAddr.ss_family == AF_INET) && (!direct(now))) { + if ((phyAddr.family() == AF_INET) && (!direct(now))) { unsigned int port = phyAddr.port(); if ((bfg1024)&&(port < 1024)&&(RR->node->natMustDie())) { // If the other side is using a low-numbered port and has elected to diff --git a/node/Peer.hpp b/node/Peer.hpp index ab7106447..634f65309 100644 --- a/node/Peer.hpp +++ b/node/Peer.hpp @@ -132,8 +132,9 @@ public: * @param localSocket Local source socket * @param atAddress Destination address * @param now Current time + * @return Number of bytes sent */ - void sendNOP(void *tPtr,int64_t localSocket,const InetAddress &atAddress,int64_t now); + unsigned int sendNOP(void *tPtr,int64_t localSocket,const InetAddress &atAddress,int64_t now); /** * Send ping to this peer diff --git a/node/README.md b/node/README.md index 1728400c3..49fb284c8 100644 --- a/node/README.md +++ b/node/README.md @@ -10,5 +10,4 @@ Code in here follows these guidelines: - Keep it minimal, especially in terms of code footprint and memory use. - There should be no OS-dependent code here unless absolutely necessary (e.g. getSecureRandom). - If it's not part of the core virtual Ethernet switch it does not belong here. - - No C++11 or C++14 since older and embedded compilers don't support it yet and this should be maximally portable. - Minimize the use of complex C++ features since at some point we might end up "minus-minus'ing" this code if doing so proves necessary to port to tiny embedded systems. diff --git a/node/SelfAwareness.cpp b/node/SelfAwareness.cpp index 0e77853d5..e57d5087d 100644 --- a/node/SelfAwareness.cpp +++ b/node/SelfAwareness.cpp @@ -81,7 +81,7 @@ void SelfAwareness::iam(void *tPtr,const Identity &reporter,const int64_t receiv } // Reset all paths within this scope and address family - _ResetWithinScope rset(tPtr,now,myPhysicalAddress.ss_family,(InetAddress::IpScope)scope); + _ResetWithinScope rset(tPtr,now,myPhysicalAddress.family(),(InetAddress::IpScope)scope); RR->topology->eachPeer<_ResetWithinScope &>(rset); RR->t->resettingPathsInScope(tPtr,0x9afff100,reporter,reporterPhysicalAddress,entry.mySurface,myPhysicalAddress,scope); diff --git a/node/Tests.cpp b/node/Tests.cpp index a39c2d50b..fedb9f2ba 100644 --- a/node/Tests.cpp +++ b/node/Tests.cpp @@ -244,6 +244,8 @@ extern "C" const char *ZTT_general() ZT_T_ASSERT(sizeof(sockaddr_in) <= sizeof(InetAddress)); ZT_T_ASSERT(sizeof(sockaddr_in6) <= sizeof(InetAddress)); ZT_T_ASSERT(sizeof(sockaddr) <= sizeof(InetAddress)); + ZT_T_ASSERT(sizeof(Hash<384>) == 48); + ZT_T_ASSERT(sizeof(Hash<512>) == 64); ZT_T_PRINTF("OK" ZT_EOL_S); } diff --git a/node/Topology.hpp b/node/Topology.hpp index 5241073dc..3d028d995 100644 --- a/node/Topology.hpp +++ b/node/Topology.hpp @@ -335,9 +335,9 @@ private: // Get a hash key for looking up paths by their local port and destination address ZT_ALWAYS_INLINE uint64_t _pathHash(int64_t l,const InetAddress &r) const { - if (r.ss_family == AF_INET) { + if (r.family() == AF_INET) { return Utils::hash64(s_pathHashSalt ^ (uint64_t)(reinterpret_cast(&r)->sin_addr.s_addr)) + (uint64_t)Utils::ntoh(reinterpret_cast(&r)->sin_port) + (uint64_t)l; - } else if (r.ss_family == AF_INET6) { + } else if (r.family() == AF_INET6) { #ifdef ZT_NO_UNALIGNED_ACCESS uint64_t h = s_pathHashSalt; for(int i=0;i<16;++i) { diff --git a/node/VL1.cpp b/node/VL1.cpp index eb7640057..d5b68da03 100644 --- a/node/VL1.cpp +++ b/node/VL1.cpp @@ -56,7 +56,7 @@ void VL1::onRemotePacket(void *const tPtr,const int64_t localSocket,const InetAd const int64_t now = RR->node->now(); // Update path's last receive time (this is updated when anything is received at all, even if invalid or a keepalive) - path->received(now); + path->received(now,len); try { // Handle 8-byte short probes, which are used as a low-bandwidth way to initiate a real handshake. @@ -69,10 +69,8 @@ void VL1::onRemotePacket(void *const tPtr,const int64_t localSocket,const InetAd // it will send its own HELLO to which we will respond with a fully encrypted OK(HELLO). if (len == ZT_PROTO_PROBE_LENGTH) { const SharedPtr peer(RR->topology->peerByProbe(data->lI64(0))); - if ((peer)&&(peer->rateGateInboundProbe(now))) { - peer->sendNOP(tPtr,path->localSocket(),path->address(),now); - path->sent(now); - } + if ((peer)&&(peer->rateGateInboundProbe(now))) + path->sent(now,peer->sendNOP(tPtr,path->localSocket(),path->address(),now)); return; }