ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/gvpe/src/connection.C
(Generate patch)

Comparing gvpe/src/connection.C (file contents):
Revision 1.59 by pcg, Mon Dec 5 12:58:09 2005 UTC vs.
Revision 1.100 by root, Wed Jul 17 05:34:17 2013 UTC

1/* 1/*
2 connection.C -- manage a single connection 2 connection.C -- manage a single connection
3 Copyright (C) 2003-2005 Marc Lehmann <gvpe@schmorp.de> 3 Copyright (C) 2003-2008,2010,2011,2013 Marc Lehmann <gvpe@schmorp.de>
4 4
5 This file is part of GVPE. 5 This file is part of GVPE.
6 6
7 GVPE is free software; you can redistribute it and/or modify 7 GVPE is free software; you can redistribute it and/or modify it
8 it under the terms of the GNU General Public License as published by 8 under the terms of the GNU General Public License as published by the
9 the Free Software Foundation; either version 2 of the License, or 9 Free Software Foundation; either version 3 of the License, or (at your
10 (at your option) any later version. 10 option) any later version.
11 11
12 This program is distributed in the hope that it will be useful, 12 This program is distributed in the hope that it will be useful, but
13 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
15 GNU General Public License for more details. 15 Public License for more details.
16 16
17 You should have received a copy of the GNU General Public License 17 You should have received a copy of the GNU General Public License along
18 along with gvpe; if not, write to the Free Software 18 with this program; if not, see <http://www.gnu.org/licenses/>.
19 Foundation, Inc. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 19
20 Additional permission under GNU GPL version 3 section 7
21
22 If you modify this Program, or any covered work, by linking or
23 combining it with the OpenSSL project's OpenSSL library (or a modified
24 version of that library), containing parts covered by the terms of the
25 OpenSSL or SSLeay licenses, the licensors of this Program grant you
26 additional permission to convey the resulting work. Corresponding
27 Source for a non-source form of such a combination shall include the
28 source code for the parts of OpenSSL used as well as that of the
29 covered work.
20*/ 30*/
21 31
22#include "config.h" 32#include "config.h"
23 33
24#include <list> 34#include <list>
35#include <queue>
36#include <utility>
25 37
26#include <openssl/rand.h> 38#include <openssl/rand.h>
27#include <openssl/evp.h> 39#include <openssl/evp.h>
28#include <openssl/rsa.h> 40#include <openssl/rsa.h>
29#include <openssl/err.h> 41#include <openssl/err.h>
… …
31#include "conf.h" 43#include "conf.h"
32#include "slog.h" 44#include "slog.h"
33#include "device.h" 45#include "device.h"
34#include "vpn.h" 46#include "vpn.h"
35#include "connection.h" 47#include "connection.h"
48#include "hkdf.h"
36 49
37#include "netcompat.h" 50#include "netcompat.h"
38 51
39#if !HAVE_RAND_PSEUDO_BYTES
40# define RAND_pseudo_bytes RAND_bytes
41#endif
42
43#define MAGIC "vped\xbd\xc6\xdb\x82" // 8 bytes of magic 52#define MAGIC "gvpe\xbd\xc6\xdb\x82" // 8 bytes of magic
44 53
45#define ULTRA_FAST 1 54#define ULTRA_FAST 1
46#define HLOG 15 55#define HLOG 15
47#include "lzf/lzf.h" 56#include "lzf/lzf.h"
48#include "lzf/lzf_c.c" 57#include "lzf/lzf_c.c"
49#include "lzf/lzf_d.c" 58#include "lzf/lzf_d.c"
50 59
60//////////////////////////////////////////////////////////////////////////////
61
62static std::queue< std::pair<run_script_cb *, const char *> > rs_queue;
63static ev::child rs_child_ev;
64
65namespace
66{
67 void // c++ requires external linkage here, apparently :(
68 rs_child_cb (ev::child &w, int revents)
69 {
70 w.stop ();
71
72 if (rs_queue.empty ())
73 return;
74
75 pid_t pid = run_script (*rs_queue.front ().first, false);
76 if (pid)
77 {
78 w.set (pid);
79 w.start ();
80 }
81 else
82 slog (L_WARN, rs_queue.front ().second);
83
84 delete rs_queue.front ().first;
85 rs_queue.pop ();
86 }
87};
88
89// despite the fancy name, this is quite a hack
90static void
91run_script_queued (run_script_cb *cb, const char *warnmsg)
92{
93 rs_queue.push (std::make_pair (cb, warnmsg));
94
95 if (!rs_child_ev.is_active ())
96 {
97 rs_child_ev.set<rs_child_cb> ();
98 rs_child_ev ();
99 }
100}
101
102//////////////////////////////////////////////////////////////////////////////
103
51struct crypto_ctx 104struct crypto_ctx
52{ 105{
53 EVP_CIPHER_CTX cctx; 106 EVP_CIPHER_CTX cctx;
54 HMAC_CTX hctx; 107 HMAC_CTX hctx;
55 108
56 crypto_ctx (const rsachallenge &challenge, int enc); 109 crypto_ctx (const auth_data &auth1, const auth_data &auth2, const ecdh_key &a, const ecdh_key &b, int enc);
57 ~crypto_ctx (); 110 ~crypto_ctx ();
58}; 111};
59 112
60crypto_ctx::crypto_ctx (const rsachallenge &challenge, int enc) 113crypto_ctx::crypto_ctx (const auth_data &auth1, const auth_data &auth2, const ecdh_key &a, const ecdh_key &b, int enc)
61{ 114{
115 ecdh_key s;
116
117 curve25519_combine (a, b, s);
118
119 {
120 u8 mac_key[MAC_KEYSIZE];
121 static const unsigned char mac_info[] = "gvpe mac key";
122
123 hkdf kdf (auth2.rsa.hkdf_salt, sizeof (auth2.rsa.hkdf_salt), HKDF_XTR_HASH ());
124 kdf.extract (auth2.rsa.ikm, sizeof (auth2.rsa.ikm));
125 kdf.extract (auth1.rsa.mac_key, sizeof (auth1.rsa.mac_key));
126 kdf.extract (s, sizeof (s));
127 kdf.extract_done (HKDF_PRF_HASH ());
128 kdf.expand (mac_key, sizeof (mac_key), mac_info, sizeof (mac_info));
129
130 HMAC_CTX_init (&hctx);
131 require (HMAC_Init_ex (&hctx, mac_key, MAC_KEYSIZE, MAC_DIGEST (), 0));
132 }
133
134 {
135 u8 cipher_key[CIPHER_KEYSIZE];
136 static const unsigned char cipher_info[] = "gvpe cipher key";
137
138 hkdf kdf (auth2.rsa.hkdf_salt, sizeof (auth2.rsa.hkdf_salt), HKDF_XTR_HASH ());
139 kdf.extract (auth2.rsa.ikm, sizeof (auth2.rsa.ikm));
140 kdf.extract (auth1.rsa.cipher_key, sizeof (auth1.rsa.cipher_key));
141 kdf.extract (s, sizeof (s));
142 kdf.extract_done (HKDF_PRF_HASH ());
143 kdf.expand (cipher_key, sizeof (cipher_key), cipher_info, sizeof (cipher_info));
144
62 EVP_CIPHER_CTX_init (&cctx); 145 EVP_CIPHER_CTX_init (&cctx);
63 require (EVP_CipherInit_ex (&cctx, CIPHER, 0, &challenge[CHG_CIPHER_KEY], 0, enc)); 146 require (EVP_CipherInit_ex (&cctx, CIPHER (), 0, cipher_key, 0, enc));
64 HMAC_CTX_init (&hctx); 147 }
65 HMAC_Init_ex (&hctx, &challenge[CHG_HMAC_KEY], HMAC_KEYLEN, DIGEST, 0);
66} 148}
67 149
68crypto_ctx::~crypto_ctx () 150crypto_ctx::~crypto_ctx ()
69{ 151{
70 require (EVP_CIPHER_CTX_cleanup (&cctx)); 152 require (EVP_CIPHER_CTX_cleanup (&cctx));
71 HMAC_CTX_cleanup (&hctx); 153 HMAC_CTX_cleanup (&hctx);
72} 154}
73 155
156static inline void
157auth_encrypt (RSA *key, const auth_data &auth, auth_encr &encr)
158{
159 if (RSA_public_encrypt (sizeof (auth.rsa),
160 (unsigned char *)&auth.rsa, (unsigned char *)&encr.rsa,
161 key, RSA_PKCS1_OAEP_PADDING) < 0)
162 fatal ("RSA_public_encrypt error");
163
164 memcpy (&encr.ecdh, &auth.ecdh, sizeof (encr.ecdh));
165}
166
167static inline bool
168auth_decrypt (RSA *key, const auth_encr &encr, auth_data &auth)
169{
170 u8 rsa_decrypt[RSA_KEYLEN];
171
172 if (RSA_private_decrypt (sizeof (encr.rsa),
173 (const unsigned char *)&encr.rsa, (unsigned char *)rsa_decrypt,
174 key, RSA_PKCS1_OAEP_PADDING) != sizeof (auth.rsa))
175 return 0;
176
177 memcpy (&auth.rsa, rsa_decrypt, sizeof (auth.rsa));
178 memcpy (&auth.ecdh, &encr.ecdh, sizeof (auth.ecdh));
179
180 return 1;
181}
182
74static void 183static void
75rsa_hash (const rsaid &id, const rsachallenge &chg, rsaresponse &h) 184auth_hash (const auth_data &auth, auth_mac &mac)
76{ 185{
77 EVP_MD_CTX ctx; 186 HMAC_CTX ctx;
78 187
79 EVP_MD_CTX_init (&ctx); 188 HMAC_CTX_init (&ctx);
80 require (EVP_DigestInit (&ctx, RSA_HASH)); 189 require (HMAC_Init_ex (&ctx, auth.rsa.auth_key, sizeof (auth.rsa.auth_key), AUTH_DIGEST (), 0));
81 require (EVP_DigestUpdate(&ctx, &chg, sizeof chg)); 190 require (HMAC_Update (&ctx, (const unsigned char *)&auth, sizeof auth));
82 require (EVP_DigestUpdate(&ctx, &id, sizeof id));
83 require (EVP_DigestFinal (&ctx, (unsigned char *)&h, 0)); 191 require (HMAC_Final (&ctx, (unsigned char *)&mac, 0));
84 EVP_MD_CTX_cleanup (&ctx); 192 HMAC_CTX_cleanup (&ctx);
85} 193}
86 194
87struct rsa_entry { 195void
88 tstamp expire; 196connection::generate_auth_data ()
89 rsaid id;
90 rsachallenge chg;
91};
92
93struct rsa_cache : list<rsa_entry>
94{ 197{
95 void cleaner_cb (time_watcher &w); time_watcher cleaner; 198 if (auth_expire < ev_now ())
96
97 bool find (const rsaid &id, rsachallenge &chg)
98 {
99 for (iterator i = begin (); i != end (); ++i)
100 { 199 {
101 if (!memcmp (&id, &i->id, sizeof id) && i->expire > NOW) 200 // request data
102 { 201 RAND_bytes ((unsigned char *)&snd_auth.rsa, sizeof snd_auth.rsa);
103 memcpy (&chg, &i->chg, sizeof chg); 202 curve25519_generate (snd_ecdh_a, snd_auth.ecdh);
203 auth_hash (snd_auth, snd_auth_mac);
104 204
105 erase (i); 205 // eventual response data
106 return true; 206 curve25519_generate (rcv_ecdh_a, rcv_ecdh_b);
107 }
108 } 207 }
109 208
110 if (cleaner.at < NOW) 209 // every use prolongs the expiry
111 cleaner.start (NOW + RSA_TTL); 210 auth_expire = ev_now () + AUTH_TTL;
112
113 return false;
114 }
115
116 void gen (rsaid &id, rsachallenge &chg)
117 {
118 rsa_entry e;
119
120 RAND_bytes ((unsigned char *)&id, sizeof id);
121 RAND_bytes ((unsigned char *)&chg, sizeof chg);
122
123 e.expire = NOW + RSA_TTL;
124 e.id = id;
125 memcpy (&e.chg, &chg, sizeof chg);
126
127 push_back (e);
128
129 if (cleaner.at < NOW)
130 cleaner.start (NOW + RSA_TTL);
131 }
132
133 rsa_cache ()
134 : cleaner (this, &rsa_cache::cleaner_cb)
135 { }
136
137} rsa_cache;
138
139void rsa_cache::cleaner_cb (time_watcher &w)
140{
141 if (!empty ())
142 {
143 w.start (NOW + RSA_TTL);
144
145 for (iterator i = begin (); i != end (); )
146 if (i->expire <= NOW)
147 i = erase (i);
148 else
149 ++i;
150 }
151} 211}
152 212
153////////////////////////////////////////////////////////////////////////////// 213//////////////////////////////////////////////////////////////////////////////
154 214
155void pkt_queue::put (net_packet *p) 215pkt_queue::pkt_queue (double max_ttl, int max_queue)
216: max_ttl (max_ttl), max_queue (max_queue)
156{ 217{
157 if (queue[i]) 218 queue = new pkt [max_queue];
158 {
159 delete queue[i];
160 j = (j + 1) % QUEUEDEPTH;
161 }
162 219
163 queue[i] = p;
164
165 i = (i + 1) % QUEUEDEPTH;
166}
167
168net_packet *pkt_queue::get ()
169{
170 net_packet *p = queue[j];
171
172 if (p)
173 {
174 queue[j] = 0;
175 j = (j + 1) % QUEUEDEPTH;
176 }
177
178 return p;
179}
180
181pkt_queue::pkt_queue ()
182{
183 memset (queue, 0, sizeof (queue));
184 i = 0; 220 i = 0;
185 j = 0; 221 j = 0;
222
223 expire.set<pkt_queue, &pkt_queue::expire_cb> (this);
186} 224}
187 225
188pkt_queue::~pkt_queue () 226pkt_queue::~pkt_queue ()
189{ 227{
190 for (i = QUEUEDEPTH; --i > 0; ) 228 while (net_packet *p = get ())
229 delete p;
230
191 delete queue[i]; 231 delete [] queue;
192} 232}
193 233
234void
235pkt_queue::expire_cb (ev::timer &w, int revents)
236{
237 ev_tstamp expire = ev_now () - max_ttl;
238
239 for (;;)
240 {
241 if (empty ())
242 break;
243
244 double diff = queue[j].tstamp - expire;
245
246 if (diff >= 0.)
247 {
248 w.start (diff > 0.5 ? diff : 0.5);
249 break;
250 }
251
252 delete get ();
253 }
254}
255
256void
257pkt_queue::put (net_packet *p)
258{
259 ev_tstamp now = ev_now ();
260
261 // start expiry timer
262 if (empty ())
263 expire.start (max_ttl);
264
265 int ni = i + 1 == max_queue ? 0 : i + 1;
266
267 if (ni == j)
268 delete get ();
269
270 queue[i].pkt = p;
271 queue[i].tstamp = now;
272
273 i = ni;
274}
275
276net_packet *
277pkt_queue::get ()
278{
279 if (empty ())
280 return 0;
281
282 net_packet *p = queue[j].pkt;
283 queue[j].pkt = 0;
284
285 j = j + 1 == max_queue ? 0 : j + 1;
286
287 return p;
288}
289
194struct net_rateinfo { 290struct net_rateinfo
291{
195 u32 host; 292 u32 host;
196 double pcnt, diff; 293 double pcnt, diff;
197 tstamp last; 294 tstamp last;
198}; 295};
199 296
… …
209 306
210 bool can (const sockinfo &si) { return can((u32)si.host); } 307 bool can (const sockinfo &si) { return can((u32)si.host); }
211 bool can (u32 host); 308 bool can (u32 host);
212}; 309};
213 310
214net_rate_limiter auth_rate_limiter, reset_rate_limiter; 311static net_rate_limiter auth_rate_limiter, reset_rate_limiter;
215 312
313bool
216bool net_rate_limiter::can (u32 host) 314net_rate_limiter::can (u32 host)
217{ 315{
218 iterator i; 316 iterator i;
219 317
220 for (i = begin (); i != end (); ) 318 for (i = begin (); i != end (); )
221 if (i->host == host) 319 if (i->host == host)
222 break; 320 break;
223 else if (i->last < NOW - NRL_EXPIRE) 321 else if (i->last < ev_now () - NRL_EXPIRE)
224 i = erase (i); 322 i = erase (i);
225 else 323 else
226 i++; 324 i++;
227 325
228 if (i == end ()) 326 if (i == end ())
… …
230 net_rateinfo ri; 328 net_rateinfo ri;
231 329
232 ri.host = host; 330 ri.host = host;
233 ri.pcnt = 1.; 331 ri.pcnt = 1.;
234 ri.diff = NRL_MAXDIF; 332 ri.diff = NRL_MAXDIF;
235 ri.last = NOW; 333 ri.last = ev_now ();
236 334
237 push_front (ri); 335 push_front (ri);
238 336
239 return true; 337 return true;
240 } 338 }
… …
242 { 340 {
243 net_rateinfo ri (*i); 341 net_rateinfo ri (*i);
244 erase (i); 342 erase (i);
245 343
246 ri.pcnt = ri.pcnt * NRL_ALPHA; 344 ri.pcnt = ri.pcnt * NRL_ALPHA;
247 ri.diff = ri.diff * NRL_ALPHA + (NOW - ri.last); 345 ri.diff = ri.diff * NRL_ALPHA + (ev_now () - ri.last);
248 346
249 ri.last = NOW; 347 ri.last = ev_now ();
250 348
251 double dif = ri.diff / ri.pcnt; 349 double dif = ri.diff / ri.pcnt;
252 350
253 bool send = dif > NRL_CUTOFF; 351 bool send = dif > NRL_CUTOFF;
254 352
… …
268 366
269///////////////////////////////////////////////////////////////////////////// 367/////////////////////////////////////////////////////////////////////////////
270 368
271unsigned char hmac_packet::hmac_digest[EVP_MAX_MD_SIZE]; 369unsigned char hmac_packet::hmac_digest[EVP_MAX_MD_SIZE];
272 370
371void
273void hmac_packet::hmac_gen (crypto_ctx *ctx) 372hmac_packet::hmac_gen (crypto_ctx *ctx)
274{ 373{
275 unsigned int xlen; 374 unsigned int xlen;
276 375
277 HMAC_CTX *hctx = &ctx->hctx; 376 HMAC_CTX *hctx = &ctx->hctx;
278 377
279 HMAC_Init_ex (hctx, 0, 0, 0, 0); 378 require (HMAC_Init_ex (hctx, 0, 0, 0, 0));
280 HMAC_Update (hctx, ((unsigned char *) this) + sizeof (hmac_packet), 379 require (HMAC_Update (hctx, ((unsigned char *) this) + sizeof (hmac_packet),
281 len - sizeof (hmac_packet)); 380 len - sizeof (hmac_packet)));
282 HMAC_Final (hctx, (unsigned char *) &hmac_digest, &xlen); 381 require (HMAC_Final (hctx, (unsigned char *) &hmac_digest, &xlen));
283} 382}
284 383
285void 384void
286hmac_packet::hmac_set (crypto_ctx *ctx) 385hmac_packet::hmac_set (crypto_ctx *ctx)
287{ 386{
… …
296 hmac_gen (ctx); 395 hmac_gen (ctx);
297 396
298 return !memcmp (hmac, hmac_digest, HMACLENGTH); 397 return !memcmp (hmac, hmac_digest, HMACLENGTH);
299} 398}
300 399
400void
301void vpn_packet::set_hdr (ptype type_, unsigned int dst) 401vpn_packet::set_hdr (ptype type_, unsigned int dst)
302{ 402{
303 type = type_; 403 type = type_;
304 404
305 int src = THISNODE->id; 405 int src = THISNODE->id;
306 406
… …
311 411
312#define MAXVPNDATA (MAX_MTU - 6 - 6) 412#define MAXVPNDATA (MAX_MTU - 6 - 6)
313#define DATAHDR (sizeof (u32) + RAND_SIZE) 413#define DATAHDR (sizeof (u32) + RAND_SIZE)
314 414
315struct vpndata_packet : vpn_packet 415struct vpndata_packet : vpn_packet
416{
417 u8 data[MAXVPNDATA + DATAHDR]; // seqno
418
419 void setup (connection *conn, int dst, u8 *d, u32 len, u32 seqno);
420 tap_packet *unpack (connection *conn, u32 &seqno);
421
422private:
423 const u32 data_hdr_size () const
316 { 424 {
317 u8 data[MAXVPNDATA + DATAHDR]; // seqno
318
319 void setup (connection *conn, int dst, u8 *d, u32 len, u32 seqno);
320 tap_packet *unpack (connection *conn, u32 &seqno);
321private:
322
323 const u32 data_hdr_size () const
324 {
325 return sizeof (vpndata_packet) - sizeof (net_packet) - MAXVPNDATA - DATAHDR; 425 return sizeof (vpndata_packet) - sizeof (net_packet) - MAXVPNDATA - DATAHDR;
326 }
327 }; 426 }
427};
328 428
329void 429void
330vpndata_packet::setup (connection *conn, int dst, u8 *d, u32 l, u32 seqno) 430vpndata_packet::setup (connection *conn, int dst, u8 *d, u32 l, u32 seqno)
331{ 431{
332 EVP_CIPHER_CTX *cctx = &conn->octx->cctx; 432 EVP_CIPHER_CTX *cctx = &conn->octx->cctx;
… …
334 ptype type = PT_DATA_UNCOMPRESSED; 434 ptype type = PT_DATA_UNCOMPRESSED;
335 435
336#if ENABLE_COMPRESSION 436#if ENABLE_COMPRESSION
337 u8 cdata[MAX_MTU]; 437 u8 cdata[MAX_MTU];
338 438
339 if (conn->features & ENABLE_COMPRESSION) 439 if (conn->features & FEATURE_COMPRESSION)
340 { 440 {
341 u32 cl = lzf_compress (d, l, cdata + 2, (l - 2) & ~7); 441 u32 cl = lzf_compress (d, l, cdata + 2, (l - 2) & ~7);
342 442
343 if (cl) 443 if (cl)
344 { 444 {
… …
350 d[1] = cl; 450 d[1] = cl;
351 } 451 }
352 } 452 }
353#endif 453#endif
354 454
355 require (EVP_EncryptInit_ex (cctx, 0, 0, 0, 0)); 455 require (EVP_CipherInit_ex (cctx, 0, 0, 0, 0, 1));
356 456
357 struct { 457 struct {
358#if RAND_SIZE 458#if RAND_SIZE
359 u8 rnd[RAND_SIZE]; 459 u8 rnd[RAND_SIZE];
360#endif 460#endif
361 u32 seqno; 461 u32 seqno;
362 } datahdr; 462 } datahdr;
363 463
364 datahdr.seqno = ntohl (seqno); 464 datahdr.seqno = ntohl (seqno);
365#if RAND_SIZE 465#if RAND_SIZE
366 RAND_pseudo_bytes ((unsigned char *) datahdr.rnd, RAND_SIZE); 466 RAND_bytes ((unsigned char *) datahdr.rnd, RAND_SIZE);
367#endif 467#endif
368 468
369 require (EVP_EncryptUpdate (cctx, 469 require (EVP_EncryptUpdate (cctx,
370 (unsigned char *) data + outl, &outl2, 470 (unsigned char *) data + outl, &outl2,
371 (unsigned char *) &datahdr, DATAHDR)); 471 (unsigned char *) &datahdr, DATAHDR));
… …
393 int outl = 0, outl2; 493 int outl = 0, outl2;
394 tap_packet *p = new tap_packet; 494 tap_packet *p = new tap_packet;
395 u8 *d; 495 u8 *d;
396 u32 l = len - data_hdr_size (); 496 u32 l = len - data_hdr_size ();
397 497
398 require (EVP_DecryptInit_ex (cctx, 0, 0, 0, 0)); 498 require (EVP_CipherInit_ex (cctx, 0, 0, 0, 0, 0));
399 499
400#if ENABLE_COMPRESSION 500#if ENABLE_COMPRESSION
401 u8 cdata[MAX_MTU]; 501 u8 cdata[MAX_MTU];
402 502
403 if (type == PT_DATA_COMPRESSED) 503 if (type == PT_DATA_COMPRESSED)
… …
445 } 545 }
446}; 546};
447 547
448struct config_packet : vpn_packet 548struct config_packet : vpn_packet
449{ 549{
450 // actually, hmaclen cannot be checked because the hmac
451 // field comes before this data, so peers with other
452 // hmacs simply will not work.
453 u8 prot_major, prot_minor, randsize, hmaclen; 550 u8 prot_major, prot_minor, randsize;
454 u8 flags, challengelen, features, pad3; 551 u8 flags, features, pad6, pad7, pad8;
455 u32 cipher_nid, digest_nid, hmac_nid; 552 u32 cipher_nid, mac_nid, auth_nid;
456 553
457 void setup (ptype type, int dst); 554 void setup (ptype type, int dst);
458 bool chk_config () const; 555 bool chk_config () const;
459 556
460 static u8 get_features () 557 static u8 get_features ()
… …
471#endif 568#endif
472 return f; 569 return f;
473 } 570 }
474}; 571};
475 572
573void
476void config_packet::setup (ptype type, int dst) 574config_packet::setup (ptype type, int dst)
477{ 575{
478 prot_major = PROTOCOL_MAJOR; 576 prot_major = PROTOCOL_MAJOR;
479 prot_minor = PROTOCOL_MINOR; 577 prot_minor = PROTOCOL_MINOR;
480 randsize = RAND_SIZE; 578 randsize = RAND_SIZE;
481 hmaclen = HMACLENGTH;
482 flags = 0; 579 flags = 0;
483 challengelen = sizeof (rsachallenge);
484 features = get_features (); 580 features = get_features ();
485 581
486 cipher_nid = htonl (EVP_CIPHER_nid (CIPHER)); 582 cipher_nid = htonl (EVP_CIPHER_nid (CIPHER ()));
487 digest_nid = htonl (EVP_MD_type (RSA_HASH));
488 hmac_nid = htonl (EVP_MD_type (DIGEST)); 583 mac_nid = htonl (EVP_MD_type (MAC_DIGEST ()));
584 auth_nid = htonl (EVP_MD_type (AUTH_DIGEST ()));
489 585
490 len = sizeof (*this) - sizeof (net_packet); 586 len = sizeof (*this) - sizeof (net_packet);
491 set_hdr (type, dst); 587 set_hdr (type, dst);
492} 588}
493 589
590bool
494bool config_packet::chk_config () const 591config_packet::chk_config () const
495{ 592{
496 if (prot_major != PROTOCOL_MAJOR) 593 if (prot_major != PROTOCOL_MAJOR)
497 slog (L_WARN, _("major version mismatch (remote %d <=> local %d)"), prot_major, PROTOCOL_MAJOR); 594 slog (L_WARN, _("major version mismatch (remote %d <=> local %d)"), prot_major, PROTOCOL_MAJOR);
498 else if (randsize != RAND_SIZE) 595 else if (randsize != RAND_SIZE)
499 slog (L_WARN, _("rand size mismatch (remote %d <=> local %d)"), randsize, RAND_SIZE); 596 slog (L_WARN, _("rand size mismatch (remote %d <=> local %d)"), randsize, RAND_SIZE);
500 else if (hmaclen != HMACLENGTH)
501 slog (L_WARN, _("hmac length mismatch (remote %d <=> local %d)"), hmaclen, HMACLENGTH);
502 else if (challengelen != sizeof (rsachallenge))
503 slog (L_WARN, _("challenge length mismatch (remote %d <=> local %d)"), challengelen, sizeof (rsachallenge));
504 else if (cipher_nid != htonl (EVP_CIPHER_nid (CIPHER))) 597 else if (cipher_nid != htonl (EVP_CIPHER_nid (CIPHER ())))
505 slog (L_WARN, _("cipher mismatch (remote %x <=> local %x)"), ntohl (cipher_nid), EVP_CIPHER_nid (CIPHER)); 598 slog (L_WARN, _("cipher algo mismatch (remote %x <=> local %x)"), ntohl (cipher_nid), EVP_CIPHER_nid (CIPHER ()));
506 else if (digest_nid != htonl (EVP_MD_type (RSA_HASH)))
507 slog (L_WARN, _("digest mismatch (remote %x <=> local %x)"), ntohl (digest_nid), EVP_MD_type (RSA_HASH));
508 else if (hmac_nid != htonl (EVP_MD_type (DIGEST))) 599 else if (mac_nid != htonl (EVP_MD_type (MAC_DIGEST ())))
509 slog (L_WARN, _("hmac mismatch (remote %x <=> local %x)"), ntohl (hmac_nid), EVP_MD_type (DIGEST)); 600 slog (L_WARN, _("mac algo mismatch (remote %x <=> local %x)"), ntohl (mac_nid), EVP_MD_type (MAC_DIGEST ()));
601 else if (auth_nid != htonl (EVP_MD_type (AUTH_DIGEST ())))
602 slog (L_WARN, _("auth algo mismatch (remote %x <=> local %x)"), ntohl (auth_nid), EVP_MD_type (AUTH_DIGEST ()));
510 else 603 else
511 return true; 604 return true;
512 605
513 return false; 606 return false;
514} 607}
515 608
516struct auth_req_packet : config_packet 609struct auth_req_packet : config_packet // UNPROTECTED
517{ 610{
518 char magic[8]; 611 char magic[8];
519 u8 initiate; // false if this is just an automatic reply 612 u8 initiate; // false if this is just an automatic reply
520 u8 protocols; // supported protocols (will be patched on forward) 613 u8 protocols; // supported protocols (will be patched on forward)
521 u8 pad2, pad3; 614 u8 pad2, pad3;
522 rsaid id; 615 auth_encr encr;
523 rsaencrdata encr;
524 616
525 auth_req_packet (int dst, bool initiate_, u8 protocols_) 617 auth_req_packet (int dst, bool initiate_, u8 protocols_)
526 { 618 {
527 config_packet::setup (PT_AUTH_REQ, dst); 619 config_packet::setup (PT_AUTH_REQ, dst);
528 strncpy (magic, MAGIC, 8); 620 memcpy (magic, MAGIC, 8);
529 initiate = !!initiate_; 621 initiate = !!initiate_;
530 protocols = protocols_; 622 protocols = protocols_;
531 623
532 len = sizeof (*this) - sizeof (net_packet); 624 len = sizeof (*this) - sizeof (net_packet);
533 } 625 }
534}; 626};
535 627
536struct auth_res_packet : config_packet 628struct auth_res_packet : config_packet // UNPROTECTED
537{ 629{
538 rsaid id;
539 u8 pad1, pad2, pad3;
540 u8 response_len; // encrypted length
541 rsaresponse response; 630 auth_response response;
542 631
543 auth_res_packet (int dst) 632 auth_res_packet (int dst)
544 { 633 {
545 config_packet::setup (PT_AUTH_RES, dst); 634 config_packet::setup (PT_AUTH_RES, dst);
546 635
… …
580}; 669};
581 670
582///////////////////////////////////////////////////////////////////////////// 671/////////////////////////////////////////////////////////////////////////////
583 672
584void 673void
585connection::connection_established () 674connection::connection_established (const sockinfo &rsi)
586{ 675{
676 if (!have_snd_auth || !have_rcv_auth)
677 return;
678
679 si = rsi;
680 protocol = rsi.prot;
681
682 slog (L_INFO, _("%s(%s): connection established (%s), protocol version %d.%d."),
683 conf->nodename, (const char *)rsi,
684 is_direct ? "direct" : "forwarded",
685 PROTOCOL_MAJOR, prot_minor);
686
687 if (::conf.script_node_up)
688 {
689 run_script_cb *cb = new run_script_cb;
690 cb->set<connection, &connection::script_node_up> (this);
691 run_script_queued (cb, _("node-up command execution failed, continuing."));
692 }
693
694 delete ictx; ictx = new crypto_ctx (rcv_auth, snd_auth, rcv_ecdh_a, rcv_auth.ecdh, 0);
695 iseqno.reset (ntohl (rcv_auth.rsa.seqno) & 0x7fffffff);
696
697 delete octx; octx = new crypto_ctx (snd_auth, rcv_auth, snd_ecdh_a, snd_ecdh_b , 1);
698 oseqno = ntohl (snd_auth.rsa.seqno) & 0x7fffffff;
699
587 if (ictx && octx) 700 if (ictx && octx)
588 { 701 {
589 connectmode = conf->connectmode;
590
591 // make sure rekeying timeouts are slightly asymmetric 702 // make sure rekeying timeouts are slightly asymmetric
592 rekey.start (NOW + ::conf.rekey 703 ev::tstamp rekey_interval = ::conf.rekey + (conf->id > THISNODE->id ? 10 : 0);
593 + (conf->id > THISNODE->id ? 10 : 0)); 704 rekey.start (rekey_interval, rekey_interval);
705
594 keepalive.start (NOW + ::conf.keepalive); 706 keepalive.start (::conf.keepalive);
595 707
596 // send queued packets 708 // send queued packets
597 if (ictx && octx) 709 if (ictx && octx)
598 { 710 {
599 while (tap_packet *p = (tap_packet *)data_queue.get ()) 711 while (tap_packet *p = (tap_packet *)data_queue.get ())
600 { 712 {
601 send_data_packet (p); 713 if (p->len) send_data_packet (p);
602 delete p; 714 delete p;
603 } 715 }
604 716
605 while (vpn_packet *p = (vpn_packet *)vpn_queue.get ()) 717 while (vpn_packet *p = (vpn_packet *)vpn_queue.get ())
606 { 718 {
607 send_vpn_packet (p, si, IPTOS_RELIABILITY); 719 if (p->len) send_vpn_packet (p, si, IPTOS_RELIABILITY);
608 delete p; 720 delete p;
609 } 721 }
610 } 722 }
723
724 vpn->connection_established (this);
611 } 725 }
726#if 0
612 else 727 else
613 { 728 {
614 retry_cnt = 0; 729 retry_cnt = 0;
615 establish_connection.start (NOW + 5); 730 establish_connection.start (5);
616 keepalive.stop (); 731 keepalive.stop ();
617 rekey.stop (); 732 rekey.stop ();
618 } 733 }
734#endif
619} 735}
620 736
621void 737void
622connection::reset_si () 738connection::reset_si ()
623{ 739{
740 if (vpn->can_direct (THISNODE, conf))
624 protocol = best_protocol (THISNODE->protocols & conf->protocols); 741 protocol = best_protocol (THISNODE->protocols & conf->connectable_protocols ());
625 742 else
626 // mask out protocols we cannot establish
627 if (!conf->udp_port) protocol &= ~PROT_UDPv4;
628 if (!conf->tcp_port) protocol &= ~PROT_TCPv4;
629 if (!conf->dns_port) protocol &= ~PROT_DNSv4;
630
631 if (protocol
632 && (!conf->can_direct (THISNODE)
633 || !THISNODE->can_direct (conf)))
634 { 743 {
635 slog (L_DEBUG, _("%s: direct connection denied"), conf->nodename); 744 slog (L_TRACE, _("%s: direct connection denied by config."), conf->nodename);
636 protocol = 0; 745 protocol = 0;
637 } 746 }
638 747
639 si.set (conf, protocol); 748 si.set (conf, protocol);
749
750 is_direct = si.valid ();
640} 751}
641 752
642// ensure sockinfo is valid, forward if necessary 753// ensure sockinfo is valid, forward if necessary
643const sockinfo & 754const sockinfo &
644connection::forward_si (const sockinfo &si) const 755connection::forward_si (const sockinfo &si) const
645{ 756{
646 if (!si.valid ()) 757 if (!si.valid ())
647 { 758 {
648 connection *r = vpn->find_router (); 759 connection *r = vpn->find_router_for (this);
649 760
650 if (r) 761 if (r)
651 { 762 {
652 slog (L_DEBUG, _("%s: no common protocol, trying indirectly through %s (%s)"), 763 slog (L_DEBUG, _("%s: no common protocol, trying to route through %s."),
653 conf->nodename, r->conf->nodename, (const char *)r->si); 764 conf->nodename, r->conf->nodename);
654 return r->si; 765 return r->si;
655 } 766 }
656 else 767 else
657 slog (L_DEBUG, _("%s: node unreachable, no common protocol"), 768 slog (L_DEBUG, _("%s: node unreachable, no common protocol or no router available."),
658 conf->nodename); 769 conf->nodename);
659 } 770 }
660 771
661 return si; 772 return si;
662} 773}
… …
672connection::send_ping (const sockinfo &si, u8 pong) 783connection::send_ping (const sockinfo &si, u8 pong)
673{ 784{
674 ping_packet *pkt = new ping_packet; 785 ping_packet *pkt = new ping_packet;
675 786
676 pkt->setup (conf->id, pong ? ping_packet::PT_PONG : ping_packet::PT_PING); 787 pkt->setup (conf->id, pong ? ping_packet::PT_PONG : ping_packet::PT_PING);
788
789 slog (L_TRACE, "%s << %s [%s]", conf->nodename, pong ? "PT_PONG" : "PT_PING", (const char *)si);
677 send_vpn_packet (pkt, si, IPTOS_LOWDELAY); 790 send_vpn_packet (pkt, si, IPTOS_LOWDELAY);
678 791
679 delete pkt; 792 delete pkt;
680} 793}
681 794
… …
696void 809void
697connection::send_auth_request (const sockinfo &si, bool initiate) 810connection::send_auth_request (const sockinfo &si, bool initiate)
698{ 811{
699 auth_req_packet *pkt = new auth_req_packet (conf->id, initiate, THISNODE->protocols); 812 auth_req_packet *pkt = new auth_req_packet (conf->id, initiate, THISNODE->protocols);
700 813
701 rsachallenge chg; 814 generate_auth_data ();
702 rsa_cache.gen (pkt->id, chg);
703 rsa_encrypt (conf->rsa_key, chg, pkt->encr); 815 auth_encrypt (conf->rsa_key, snd_auth, pkt->encr);
704 816
705 slog (L_TRACE, ">>%d PT_AUTH_REQ [%s]", conf->id, (const char *)si); 817 slog (L_TRACE, "%s << PT_AUTH_REQ [%s]", conf->nodename, (const char *)si);
706
707 send_vpn_packet (pkt, si, IPTOS_RELIABILITY | IPTOS_LOWDELAY); // rsa is very very costly 818 send_vpn_packet (pkt, si, IPTOS_RELIABILITY | IPTOS_LOWDELAY); // rsa is very very costly
708 819
709 delete pkt; 820 delete pkt;
710} 821}
711 822
712void 823void
713connection::send_auth_response (const sockinfo &si, const rsaid &id, const rsachallenge &chg) 824connection::send_auth_response (const sockinfo &si)
714{ 825{
715 auth_res_packet *pkt = new auth_res_packet (conf->id); 826 auth_res_packet *pkt = new auth_res_packet (conf->id);
716 827
717 pkt->id = id; 828 auth_hash (rcv_auth, pkt->response.mac);
829 memcpy (pkt->response.ecdh, rcv_ecdh_b, sizeof (rcv_ecdh_b));
718 830
719 rsa_hash (id, chg, pkt->response);
720
721 pkt->hmac_set (octx);
722
723 slog (L_TRACE, ">>%d PT_AUTH_RES [%s]", conf->id, (const char *)si); 831 slog (L_TRACE, "%s << PT_AUTH_RES [%s]", conf->nodename, (const char *)si);
724
725 send_vpn_packet (pkt, si, IPTOS_RELIABILITY); // rsa is very very costly 832 send_vpn_packet (pkt, si, IPTOS_RELIABILITY); // rsa is very very costly
726 833
727 delete pkt; 834 delete pkt;
728} 835}
729 836
730void 837void
731connection::send_connect_info (int rid, const sockinfo &rsi, u8 rprotocols) 838connection::send_connect_info (int rid, const sockinfo &rsi, u8 rprotocols)
732{ 839{
733 slog (L_TRACE, ">>%d PT_CONNECT_INFO(%d,%s)", 840 slog (L_TRACE, "%s << PT_CONNECT_INFO(%s,%s,p%02x)", conf->nodename,
734 conf->id, rid, (const char *)rsi); 841 vpn->conns[rid - 1]->conf->nodename, (const char *)rsi,
842 conf->protocols);
735 843
736 connect_info_packet *r = new connect_info_packet (conf->id, rid, rsi, rprotocols); 844 connect_info_packet *r = new connect_info_packet (conf->id, rid, rsi, rprotocols);
737 845
738 r->hmac_set (octx); 846 r->hmac_set (octx);
739 send_vpn_packet (r, si); 847 send_vpn_packet (r, si);
740 848
741 delete r; 849 delete r;
742} 850}
743 851
744void 852inline void
745connection::establish_connection_cb (time_watcher &w) 853connection::establish_connection_cb (ev::timer &w, int revents)
746{ 854{
747 if (!ictx 855 if (!(ictx && octx)
748 && conf != THISNODE 856 && conf != THISNODE
749 && connectmode != conf_node::C_NEVER 857 && connectmode != conf_node::C_NEVER
750 && connectmode != conf_node::C_DISABLED 858 && connectmode != conf_node::C_DISABLED
751 && NOW > w.at) 859 && !w.is_active ())
752 { 860 {
753 w.at = TSTAMP_MAX; // first disable this watcher in case of recursion 861 // a bit hacky, if ondemand, and packets are no longer queued, then reset the connection
862 // and stop trying. should probably be handled by a per-connection expire handler.
863 if (connectmode == conf_node::C_ONDEMAND && vpn_queue.empty () && data_queue.empty ())
864 {
865 reset_connection ();
866 return;
867 }
754 868
755 double retry_int = double (retry_cnt & 3 869 last_establish_attempt = ev_now ();
870
871 ev::tstamp retry_int = ev::tstamp (retry_cnt & 3
756 ? (retry_cnt & 3) + 1 872 ? (retry_cnt & 3) + 1
757 : 1 << (retry_cnt >> 2)); 873 : 1 << (retry_cnt >> 2));
758 874
759 reset_si (); 875 reset_si ();
760 876
761 bool slow = si.prot & PROT_SLOW; 877 bool slow = si.prot & PROT_SLOW;
762 878
763 if (si.prot && !si.host) 879 if (si.prot && !si.host && vpn->can_direct (THISNODE, conf))
880 {
881 /*TODO*/ /* start the timer so we don't recurse endlessly */
882 w.start (1);
764 vpn->send_connect_request (conf->id); 883 vpn->send_connect_request (this);
884 }
765 else 885 else
766 { 886 {
887 if (si.valid ())
888 slog (L_DEBUG, _("%s: sending direct connection request to %s."),
889 conf->nodename, (const char *)si);
890
767 const sockinfo &dsi = forward_si (si); 891 const sockinfo &dsi = forward_si (si);
768 892
769 slow = slow || (dsi.prot & PROT_SLOW); 893 slow = slow || (dsi.prot & PROT_SLOW);
770 894
771 if (dsi.valid () && auth_rate_limiter.can (dsi)) 895 if (dsi.valid () && auth_rate_limiter.can (dsi))
… …
775 else 899 else
776 send_ping (dsi, 0); 900 send_ping (dsi, 0);
777 } 901 }
778 } 902 }
779 903
780 retry_int *= slow ? 8. : 0.7; 904 retry_int *= slow ? 8. : 0.9;
781 905
782 if (retry_int < conf->max_retry) 906 if (retry_int < conf->max_retry)
783 retry_cnt++; 907 retry_cnt++;
784 else 908 else
785 retry_int = conf->max_retry; 909 retry_int = conf->max_retry;
786 910
787 w.start (NOW + retry_int); 911 w.start (retry_int);
788 } 912 }
789} 913}
790 914
791void 915void
792connection::reset_connection () 916connection::reset_connection ()
… …
795 { 919 {
796 slog (L_INFO, _("%s(%s): connection lost"), 920 slog (L_INFO, _("%s(%s): connection lost"),
797 conf->nodename, (const char *)si); 921 conf->nodename, (const char *)si);
798 922
799 if (::conf.script_node_down) 923 if (::conf.script_node_down)
800 if (!run_script (run_script_cb (this, &connection::script_node_down), false)) 924 {
925 run_script_cb *cb = new run_script_cb;
926 cb->set<connection, &connection::script_node_down> (this);
801 slog (L_WARN, _("node-down command execution failed, continuing.")); 927 run_script_queued (cb, _("node-down command execution failed, continuing."));
928 }
802 } 929 }
803 930
804 delete ictx; ictx = 0; 931 delete ictx; ictx = 0;
805 delete octx; octx = 0; 932 delete octx; octx = 0;
806#if ENABLE_DNS
807 dnsv4_reset_connection ();
808#endif
809 933
810 si.host = 0; 934 si.host = 0;
811 935
936 have_snd_auth = false;
937 have_rcv_auth = false;
938 auth_expire = 0.;
939
812 last_activity = 0; 940 last_activity = 0.;
941 //last_si_change = 0.;
813 retry_cnt = 0; 942 retry_cnt = 0;
814 943
815 rekey.stop (); 944 rekey.stop ();
816 keepalive.stop (); 945 keepalive.stop ();
817 establish_connection.stop (); 946 establish_connection.stop ();
… …
824 send_reset (si); 953 send_reset (si);
825 954
826 reset_connection (); 955 reset_connection ();
827} 956}
828 957
829void 958// poor-man's rekeying
830connection::rekey_cb (time_watcher &w) 959inline void
960connection::rekey_cb (ev::timer &w, int revents)
831{ 961{
832 reset_connection (); 962 reset_connection ();
833 establish_connection (); 963 establish_connection ();
834} 964}
835 965
… …
851 if (oseqno > MAX_SEQNO) 981 if (oseqno > MAX_SEQNO)
852 rekey (); 982 rekey ();
853} 983}
854 984
855void 985void
986connection::post_inject_queue ()
987{
988 // force a connection every now and when when packets are sent (max 1/s)
989 if (ev_now () - last_establish_attempt >= 0.95) // arbitrary
990 establish_connection.stop ();
991
992 establish_connection ();
993}
994
995void
856connection::inject_data_packet (tap_packet *pkt, bool broadcast/*TODO DDD*/) 996connection::inject_data_packet (tap_packet *pkt)
857{ 997{
858 if (ictx && octx) 998 if (ictx && octx)
859 send_data_packet (pkt); 999 send_data_packet (pkt);
860 else 1000 else
861 { 1001 {
862 if (!broadcast)
863 data_queue.put (new tap_packet (*pkt)); 1002 data_queue.put (new tap_packet (*pkt));
864 1003 post_inject_queue ();
865 establish_connection ();
866 } 1004 }
867} 1005}
868 1006
1007void
869void connection::inject_vpn_packet (vpn_packet *pkt, int tos) 1008connection::inject_vpn_packet (vpn_packet *pkt, int tos)
870{ 1009{
871 if (ictx && octx) 1010 if (ictx && octx)
872 send_vpn_packet (pkt, si, tos); 1011 send_vpn_packet (pkt, si, tos);
873 else 1012 else
874 { 1013 {
875 vpn_queue.put ((vpn_packet *)new data_packet (*(data_packet *)pkt)); 1014 vpn_queue.put ((vpn_packet *)new data_packet (*(data_packet *)pkt));
876 1015 post_inject_queue ();
877 establish_connection ();
878 } 1016 }
879} 1017}
880 1018
881void 1019void
882connection::recv_vpn_packet (vpn_packet *pkt, const sockinfo &rsi) 1020connection::recv_vpn_packet (vpn_packet *pkt, const sockinfo &rsi)
883{ 1021{
884 last_activity = NOW; 1022 last_activity = ev_now ();
885 1023
886 slog (L_NOISE, "<<%d received packet type %d from %d to %d", 1024 slog (L_NOISE, "%s >> received packet type %d from %d to %d.",
887 conf->id, pkt->typ (), pkt->src (), pkt->dst ()); 1025 conf->nodename, pkt->typ (), pkt->src (), pkt->dst ());
1026
1027 if (connectmode == conf_node::C_DISABLED)
1028 return;
888 1029
889 switch (pkt->typ ()) 1030 switch (pkt->typ ())
890 { 1031 {
891 case vpn_packet::PT_PING: 1032 case vpn_packet::PT_PING:
1033 slog (L_TRACE, "%s >> PT_PING", conf->nodename);
1034
892 // we send pings instead of auth packets after some retries, 1035 // we send pings instead of auth packets after some retries,
893 // so reset the retry counter and establish a connection 1036 // so reset the retry counter and establish a connection
894 // when we receive a ping. 1037 // when we receive a ping.
895 if (!ictx) 1038 if (!ictx)
896 { 1039 {
897 if (auth_rate_limiter.can (rsi)) 1040 if (auth_rate_limiter.can (rsi))
898 send_auth_request (rsi, true); 1041 send_auth_request (rsi, true);
899 } 1042 }
900 else 1043 else
1044 // we would love to change the socket address here, but ping's aren't
1045 // authenticated, so we best ignore it.
901 send_ping (rsi, 1); // pong 1046 send_ping (rsi, 1); // pong
902 1047
903 break; 1048 break;
904 1049
905 case vpn_packet::PT_PONG: 1050 case vpn_packet::PT_PONG:
1051 slog (L_TRACE, "%s >> PT_PONG", conf->nodename);
1052
1053 // a PONG might mean that the other side doesn't really know
1054 // about our desire for communication.
1055 establish_connection ();
906 break; 1056 break;
907 1057
908 case vpn_packet::PT_RESET: 1058 case vpn_packet::PT_RESET:
909 { 1059 {
910 reset_connection (); 1060 reset_connection ();
911 1061
912 config_packet *p = (config_packet *) pkt; 1062 config_packet *p = (config_packet *) pkt;
913 1063
914 if (!p->chk_config ()) 1064 if (!p->chk_config ())
915 { 1065 {
916 slog (L_WARN, _("%s(%s): protocol mismatch, disabling node"), 1066 slog (L_WARN, _("%s(%s): protocol mismatch, disabling node."),
917 conf->nodename, (const char *)rsi); 1067 conf->nodename, (const char *)rsi);
918 connectmode = conf_node::C_DISABLED; 1068 connectmode = conf_node::C_DISABLED;
919 } 1069 }
920 else if (connectmode == conf_node::C_ALWAYS) 1070 else if (connectmode == conf_node::C_ALWAYS)
921 establish_connection (); 1071 establish_connection ();
… …
923 break; 1073 break;
924 1074
925 case vpn_packet::PT_AUTH_REQ: 1075 case vpn_packet::PT_AUTH_REQ:
926 if (auth_rate_limiter.can (rsi)) 1076 if (auth_rate_limiter.can (rsi))
927 { 1077 {
928 auth_req_packet *p = (auth_req_packet *) pkt; 1078 auth_req_packet *p = (auth_req_packet *)pkt;
929 1079
930 slog (L_TRACE, "<<%d PT_AUTH_REQ(%d)", conf->id, p->initiate); 1080 slog (L_TRACE, "%s >> PT_AUTH_REQ(%s,p%02x,f%02x)",
1081 conf->nodename, p->initiate ? "initiate" : "reply",
1082 p->protocols, p->features);
931 1083
932 if (p->chk_config () && !strncmp (p->magic, MAGIC, 8)) 1084 if (p->chk_config () && !memcmp (p->magic, MAGIC, 8))
933 { 1085 {
934 if (p->prot_minor != PROTOCOL_MINOR) 1086 if (p->prot_minor != PROTOCOL_MINOR)
935 slog (L_INFO, _("%s(%s): protocol minor version mismatch: ours is %d, %s's is %d."), 1087 slog (L_INFO, _("%s(%s): protocol minor version mismatch: ours is %d, %s's is %d."),
936 conf->nodename, (const char *)rsi, 1088 conf->nodename, (const char *)rsi,
937 PROTOCOL_MINOR, conf->nodename, p->prot_minor); 1089 PROTOCOL_MINOR, conf->nodename, p->prot_minor);
938 1090
939 if (p->initiate) 1091 if (p->initiate)
940 send_auth_request (rsi, false); 1092 send_auth_request (rsi, false);
941 1093
942 rsachallenge k; 1094 auth_data auth;
943 1095
944 if (!rsa_decrypt (::conf.rsa_key, p->encr, k)) 1096 if (!auth_decrypt (::conf.rsa_key, p->encr, auth))
945 { 1097 {
946 slog (L_ERR, _("%s(%s): challenge illegal or corrupted (%s). mismatched key or config file?"), 1098 slog (L_ERR, _("%s(%s): challenge illegal or corrupted (%s). mismatched key or config file?"),
947 conf->nodename, (const char *)rsi, ERR_error_string (ERR_get_error (), 0)); 1099 conf->nodename, (const char *)rsi, ERR_error_string (ERR_get_error (), 0));
948 break;
949 } 1100 }
950 else 1101 else
951 { 1102 {
952 delete octx; 1103 bool chg = !have_rcv_auth || memcmp (&rcv_auth, &auth, sizeof auth);
953 1104
954 octx = new crypto_ctx (k, 1); 1105 rcv_auth = auth;
955 oseqno = ntohl (*(u32 *)&k[CHG_SEQNO]) & 0x7fffffff; 1106 have_rcv_auth = true;
956 1107
1108 send_auth_response (rsi);
1109
1110 if (chg)
1111 {
957 conf->protocols = p->protocols; 1112 conf->protocols = p->protocols;
958 features = p->features & config_packet::get_features (); 1113 features = p->features & config_packet::get_features ();
959 1114
960 send_auth_response (rsi, p->id, k);
961
962 connection_established (); 1115 connection_established (rsi);
963
964 break; 1116 }
965 } 1117 }
1118
1119 break;
966 } 1120 }
967 else 1121 else
968 slog (L_WARN, _("%s(%s): protocol mismatch"), 1122 slog (L_WARN, _("%s(%s): protocol mismatch."),
969 conf->nodename, (const char *)rsi); 1123 conf->nodename, (const char *)rsi);
970 1124
971 send_reset (rsi); 1125 send_reset (rsi);
972 } 1126 }
973 1127
974 break; 1128 break;
975 1129
976 case vpn_packet::PT_AUTH_RES: 1130 case vpn_packet::PT_AUTH_RES:
977 { 1131 {
978 auth_res_packet *p = (auth_res_packet *) pkt; 1132 auth_res_packet *p = (auth_res_packet *)pkt;
979 1133
980 slog (L_TRACE, "<<%d PT_AUTH_RES", conf->id); 1134 slog (L_TRACE, "%s >> PT_AUTH_RES", conf->nodename);
981 1135
982 if (p->chk_config ()) 1136 if (p->chk_config ())
983 { 1137 {
984 if (p->prot_minor != PROTOCOL_MINOR) 1138 if (memcmp (&p->response.mac, snd_auth_mac, sizeof (snd_auth_mac)))
985 slog (L_INFO, _("%s(%s): protocol minor version mismatch: ours is %d, %s's is %d."),
986 conf->nodename, (const char *)rsi,
987 PROTOCOL_MINOR, conf->nodename, p->prot_minor);
988
989 rsachallenge chg;
990
991 if (!rsa_cache.find (p->id, chg))
992 { 1139 {
993 slog (L_ERR, _("%s(%s): unrequested auth response ignored"), 1140 slog (L_ERR, _("%s(%s): unrequested or outdated auth response, ignoring."),
994 conf->nodename, (const char *)rsi); 1141 conf->nodename, (const char *)rsi);
995 break;
996 } 1142 }
997 else 1143 else if (!have_snd_auth)
998 { 1144 {
999 crypto_ctx *cctx = new crypto_ctx (chg, 0); 1145 if (p->prot_minor != PROTOCOL_MINOR)
1000 1146 slog (L_INFO, _("%s(%s): protocol minor version mismatch: ours is %d, %s's is %d."),
1001 if (!p->hmac_chk (cctx))
1002 {
1003 slog (L_ERR, _("%s(%s): hmac authentication error on auth response, received invalid packet\n"
1004 "could be an attack, or just corruption or a synchronization error"),
1005 conf->nodename, (const char *)rsi); 1147 conf->nodename, (const char *)rsi,
1006 break; 1148 PROTOCOL_MINOR, conf->nodename, p->prot_minor);
1007 }
1008 else
1009 {
1010 rsaresponse h;
1011 1149
1012 rsa_hash (p->id, chg, h);
1013
1014 if (!memcmp ((u8 *)&h, (u8 *)p->response, sizeof h))
1015 {
1016 prot_minor = p->prot_minor; 1150 prot_minor = p->prot_minor;
1151 memcpy (snd_ecdh_b, p->response.ecdh, sizeof (snd_ecdh_b));
1017 1152
1018 delete ictx; ictx = cctx; 1153 have_snd_auth = true;
1019
1020 iseqno.reset (ntohl (*(u32 *)&chg[CHG_SEQNO]) & 0x7fffffff); // at least 2**31 sequence numbers are valid
1021
1022 si = rsi;
1023 protocol = rsi.prot;
1024
1025 connection_established (); 1154 connection_established (rsi);
1026
1027 slog (L_INFO, _("%s(%s): connection established, protocol version %d.%d"),
1028 conf->nodename, (const char *)rsi,
1029 p->prot_major, p->prot_minor);
1030
1031 if (::conf.script_node_up)
1032 if (!run_script (run_script_cb (this, &connection::script_node_up), false))
1033 slog (L_WARN, _("node-up command execution failed, continuing."));
1034
1035 break;
1036 }
1037 else
1038 slog (L_ERR, _("%s(%s): sent and received challenge do not match"),
1039 conf->nodename, (const char *)rsi);
1040 }
1041
1042 delete cctx;
1043 } 1155 }
1156
1157 break;
1044 } 1158 }
1045 } 1159 }
1046 1160
1047 send_reset (rsi); 1161 send_reset (rsi);
1048 break; 1162 break;
… …
1059 { 1173 {
1060 vpndata_packet *p = (vpndata_packet *)pkt; 1174 vpndata_packet *p = (vpndata_packet *)pkt;
1061 1175
1062 if (!p->hmac_chk (ictx)) 1176 if (!p->hmac_chk (ictx))
1063 slog (L_ERR, _("%s(%s): hmac authentication error, received invalid packet\n" 1177 slog (L_ERR, _("%s(%s): hmac authentication error, received invalid packet\n"
1064 "could be an attack, or just corruption or a synchronization error"), 1178 "could be an attack, or just corruption or a synchronization error."),
1065 conf->nodename, (const char *)rsi); 1179 conf->nodename, (const char *)rsi);
1066 else 1180 else
1067 { 1181 {
1068 u32 seqno; 1182 u32 seqno;
1069 tap_packet *d = p->unpack (this, seqno); 1183 tap_packet *d = p->unpack (this, seqno);
1184 int seqclass = iseqno.seqno_classify (seqno);
1070 1185
1071 if (iseqno.recv_ok (seqno)) 1186 if (seqclass == 0) // ok
1072 { 1187 {
1073 vpn->tap->send (d); 1188 vpn->tap->send (d);
1074 1189
1075 if (si != rsi) 1190 if (si != rsi)
1076 { 1191 {
1077 // fast re-sync on source address changes, useful especially for tcp/ip 1192 // fast re-sync on source address changes, useful especially for tcp/ip
1193 //if (last_si_change < ev_now () + 5.)
1078 si = rsi; 1194 // {
1079
1080 slog (L_INFO, _("%s(%s): socket address changed to %s"), 1195 slog (L_INFO, _("%s(%s): changing socket address to %s."),
1081 conf->nodename, (const char *)si, (const char *)rsi); 1196 conf->nodename, (const char *)si, (const char *)rsi);
1197
1198 si = rsi;
1199
1200 if (::conf.script_node_change)
1201 {
1202 run_script_cb *cb = new run_script_cb;
1203 cb->set<connection, &connection::script_node_change> (this);
1204 run_script_queued (cb, _("node-change command execution failed, continuing."));
1205 }
1206
1207 // }
1208 //else
1209 // slog (L_INFO, _("%s(%s): accepted packet from %s, not (yet) redirecting traffic."),
1210 // conf->nodename, (const char *)si, (const char *)rsi);
1082 } 1211 }
1212 }
1213 else if (seqclass == 1) // far history
1214 slog (L_ERR, _("received very old packet (received %08lx, expected %08lx). "
1215 "possible replay attack, or just packet duplication/delay, ignoring."), seqno, iseqno.seq + 1);
1216 else if (seqclass == 2) // in-window duplicate, happens often on wireless
1217 slog (L_DEBUG, _("received recent duplicated packet (received %08lx, expected %08lx). "
1218 "possible replay attack, or just packet duplication, ignoring."), seqno, iseqno.seq + 1);
1219 else if (seqclass == 3) // reset
1220 {
1221 slog (L_ERR, _("received out-of-sync (far future) packet (received %08lx, expected %08lx). "
1222 "probably just massive packet loss, sending reset."), seqno, iseqno.seq + 1);
1223 send_reset (rsi);
1083 } 1224 }
1084 1225
1085 delete d; 1226 delete d;
1086 break; 1227 break;
1087 } 1228 }
… …
1091 break; 1232 break;
1092 1233
1093 case vpn_packet::PT_CONNECT_REQ: 1234 case vpn_packet::PT_CONNECT_REQ:
1094 if (ictx && octx && rsi == si && pkt->hmac_chk (ictx)) 1235 if (ictx && octx && rsi == si && pkt->hmac_chk (ictx))
1095 { 1236 {
1096 connect_req_packet *p = (connect_req_packet *) pkt; 1237 connect_req_packet *p = (connect_req_packet *)pkt;
1097 1238
1098 if (p->id > 0 && p->id <= vpn->conns.size ()) 1239 if (p->id > 0 && p->id <= vpn->conns.size ())
1099 { 1240 {
1100 connection *c = vpn->conns[p->id - 1]; 1241 connection *c = vpn->conns[p->id - 1];
1101 conf->protocols = p->protocols; 1242 conf->protocols = p->protocols;
1102 1243
1103 slog (L_TRACE, "<<%d PT_CONNECT_REQ(%d) [%d]", 1244 slog (L_TRACE, "%s >> PT_CONNECT_REQ(%s,p%02x) [%d]",
1245 conf->nodename, vpn->conns[p->id - 1]->conf->nodename,
1246 p->protocols,
1104 conf->id, p->id, c->ictx && c->octx); 1247 c->ictx && c->octx);
1105 1248
1106 if (c->ictx && c->octx) 1249 if (c->ictx && c->octx)
1107 { 1250 {
1108 // send connect_info packets to both sides, in case one is 1251 // send connect_info packets to both sides, in case one is
1109 // behind a nat firewall (or both ;) 1252 // behind a nat firewall (or both ;)
… …
1132 1275
1133 c->conf->protocols = p->protocols; 1276 c->conf->protocols = p->protocols;
1134 protocol = best_protocol (c->conf->protocols & THISNODE->protocols & p->si.supported_protocols (c->conf)); 1277 protocol = best_protocol (c->conf->protocols & THISNODE->protocols & p->si.supported_protocols (c->conf));
1135 p->si.upgrade_protocol (protocol, c->conf); 1278 p->si.upgrade_protocol (protocol, c->conf);
1136 1279
1137 slog (L_TRACE, "<<%d PT_CONNECT_INFO(%d,%s) (%d)", 1280 slog (L_TRACE, "%s >> PT_CONNECT_INFO(%s,%s,protocols=%02x,protocol=%02x,upgradable=%02x) [%d]",
1138 conf->id, p->id, (const char *)p->si, !c->ictx && !c->octx); 1281 conf->nodename,
1282 vpn->conns[p->id - 1]->conf->nodename,
1283 (const char *)p->si,
1284 p->protocols,
1285 protocol,
1286 p->si.supported_protocols (c->conf),
1287 !c->ictx && !c->octx);
1139 1288
1140 const sockinfo &dsi = forward_si (p->si); 1289 const sockinfo &dsi = forward_si (p->si);
1141 1290
1142 if (dsi.valid ()) 1291 if (dsi.valid ())
1143 c->send_auth_request (dsi, true); 1292 c->send_auth_request (dsi, true);
1293 else
1294 slog (L_INFO, "connect info for %s received (%s), but still unable to contact.",
1295 vpn->conns[p->id - 1]->conf->nodename,
1296 (const char *)p->si);
1144 } 1297 }
1145 else 1298 else
1146 slog (L_WARN, 1299 slog (L_WARN,
1147 _("received authenticated connection request from unknown node #%d, config file mismatch?"), 1300 _("received authenticated connection request from unknown node #%d, config file mismatch?"),
1148 p->id); 1301 p->id);
… …
1154 send_reset (rsi); 1307 send_reset (rsi);
1155 break; 1308 break;
1156 } 1309 }
1157} 1310}
1158 1311
1159void connection::keepalive_cb (time_watcher &w) 1312inline void
1313connection::keepalive_cb (ev::timer &w, int revents)
1160{ 1314{
1161 if (NOW >= last_activity + ::conf.keepalive + 30) 1315 ev_tstamp when = last_activity + ::conf.keepalive - ev::now ();
1316
1317 if (when >= 0)
1318 w.start (when);
1319 else if (when < -15)
1162 { 1320 {
1163 reset_connection (); 1321 reset_connection ();
1164 establish_connection (); 1322 establish_connection ();
1165 } 1323 }
1166 else if (NOW < last_activity + ::conf.keepalive)
1167 w.start (last_activity + ::conf.keepalive);
1168 else if (conf->connectmode != conf_node::C_ONDEMAND 1324 else if (conf->connectmode != conf_node::C_ONDEMAND
1169 || THISNODE->connectmode != conf_node::C_ONDEMAND) 1325 || THISNODE->connectmode != conf_node::C_ONDEMAND)
1170 { 1326 {
1327 w.start (3);
1171 send_ping (si); 1328 send_ping (si);
1172 w.start (NOW + 5);
1173 } 1329 }
1174 else if (NOW < last_activity + ::conf.keepalive + 10) 1330 else if (when >= -10)
1175 // hold ondemand connections implicitly a few seconds longer 1331 // hold ondemand connections implicitly a few seconds longer
1176 // should delete octx, though, or something like that ;) 1332 // should delete octx, though, or something like that ;)
1177 w.start (last_activity + ::conf.keepalive + 10); 1333 w.start (when + 10);
1178 else 1334 else
1179 reset_connection (); 1335 reset_connection ();
1180} 1336}
1181 1337
1338void
1182void connection::send_connect_request (int id) 1339connection::send_connect_request (int id)
1183{ 1340{
1184 connect_req_packet *p = new connect_req_packet (conf->id, id, conf->protocols); 1341 connect_req_packet *p = new connect_req_packet (conf->id, id, THISNODE->protocols);
1185 1342
1186 slog (L_TRACE, ">>%d PT_CONNECT_REQ(%d)", conf->id, id); 1343 slog (L_TRACE, "%s << PT_CONNECT_REQ(%s,p%02x)",
1344 conf->nodename, vpn->conns[id - 1]->conf->nodename,
1345 THISNODE->protocols);
1187 p->hmac_set (octx); 1346 p->hmac_set (octx);
1188 send_vpn_packet (p, si); 1347 send_vpn_packet (p, si);
1189 1348
1190 delete p; 1349 delete p;
1191} 1350}
1192 1351
1352void
1193void connection::script_init_env (const char *ext) 1353connection::script_init_env (const char *ext)
1194{ 1354{
1195 char *env; 1355 char *env;
1196 asprintf (&env, "IFUPDATA%s=%s", ext, conf->if_up_data); putenv (env); 1356 asprintf (&env, "IFUPDATA%s=%s", ext, conf->if_up_data); putenv (env);
1197 asprintf (&env, "NODENAME%s=%s", ext, conf->nodename); putenv (env); 1357 asprintf (&env, "NODENAME%s=%s", ext, conf->nodename); putenv (env);
1198 asprintf (&env, "MAC%s=%02x:%02x:%02x:%02x:%02x:%02x", ext, 1358 asprintf (&env, "MAC%s=%02x:%02x:%02x:%02x:%02x:%02x", ext,
1199 0xfe, 0xfd, 0x80, 0x00, conf->id >> 8, 1359 0xfe, 0xfd, 0x80, 0x00, conf->id >> 8,
1200 conf->id & 0xff); putenv (env); 1360 conf->id & 0xff); putenv (env);
1201} 1361}
1202 1362
1363void
1203void connection::script_init_connect_env () 1364connection::script_init_connect_env ()
1204{ 1365{
1205 vpn->script_init_env (); 1366 vpn->script_init_env ();
1206 1367
1207 char *env; 1368 char *env;
1208 asprintf (&env, "DESTID=%d", conf->id); putenv (env); 1369 asprintf (&env, "DESTID=%d", conf->id); putenv (env);
1370 asprintf (&env, "DESTSI=%s", (const char *)si); putenv (env);
1209 asprintf (&env, "DESTNODE=%s", conf->nodename); putenv (env); 1371 asprintf (&env, "DESTNODE=%s", conf->nodename); putenv (env);
1210 asprintf (&env, "DESTIP=%s", si.ntoa ()); putenv (env); 1372 asprintf (&env, "DESTIP=%s", si.ntoa ()); putenv (env);
1211 asprintf (&env, "DESTPORT=%d", ntohs (si.port)); putenv (env); 1373 asprintf (&env, "DESTPORT=%d", ntohs (si.port)); putenv (env);
1212} 1374}
1213 1375
1376inline const char *
1214const char *connection::script_node_up () 1377connection::script_node_up ()
1215{ 1378{
1216 script_init_connect_env (); 1379 script_init_connect_env ();
1217 1380
1218 putenv ("STATE=up"); 1381 putenv ((char *)"STATE=up");
1219 1382
1220 char *filename; 1383 char *filename;
1221 asprintf (&filename, 1384 asprintf (&filename,
1222 "%s/%s", 1385 "%s/%s",
1223 confbase, 1386 confbase,
1224 ::conf.script_node_up ? ::conf.script_node_up : "node-up"); 1387 ::conf.script_node_up ? ::conf.script_node_up : "node-up");
1225 1388
1226 return filename; 1389 return filename;
1227} 1390}
1228 1391
1229const char *connection::script_node_down () 1392inline const char *
1393connection::script_node_change ()
1230{ 1394{
1231 script_init_connect_env (); 1395 script_init_connect_env ();
1232 1396
1397 putenv ((char *)"STATE=change");
1398
1399 char *filename;
1400 asprintf (&filename,
1401 "%s/%s",
1402 confbase,
1403 ::conf.script_node_change ? ::conf.script_node_change : "node-change");
1404
1405 return filename;
1406}
1407
1408inline const char *
1409connection::script_node_down ()
1410{
1411 script_init_connect_env ();
1412
1233 putenv ("STATE=down"); 1413 putenv ((char *)"STATE=down");
1234 1414
1235 char *filename; 1415 char *filename;
1236 asprintf (&filename, 1416 asprintf (&filename,
1237 "%s/%s", 1417 "%s/%s",
1238 confbase, 1418 confbase,
… …
1240 1420
1241 return filename; 1421 return filename;
1242} 1422}
1243 1423
1244connection::connection (struct vpn *vpn, conf_node *conf) 1424connection::connection (struct vpn *vpn, conf_node *conf)
1245: vpn(vpn), conf(conf) 1425: vpn(vpn), conf(conf),
1246, rekey (this, &connection::rekey_cb)
1247, keepalive (this, &connection::keepalive_cb)
1248, establish_connection (this, &connection::establish_connection_cb)
1249#if ENABLE_DNS 1426#if ENABLE_DNS
1250, dns (0) 1427 dns (0),
1251#endif 1428#endif
1429 data_queue(conf->max_ttl, conf->max_queue + 1),
1430 vpn_queue(conf->max_ttl, conf->max_queue + 1)
1252{ 1431{
1432 rekey .set<connection, &connection::rekey_cb > (this);
1433 keepalive .set<connection, &connection::keepalive_cb > (this);
1434 establish_connection.set<connection, &connection::establish_connection_cb> (this);
1435
1436 last_establish_attempt = 0.;
1253 octx = ictx = 0; 1437 octx = ictx = 0;
1254 retry_cnt = 0;
1255 1438
1256 if (!conf->protocols) // make sure some protocol is enabled 1439 connectmode = conf->connectmode;
1257 conf->protocols = PROT_UDPv4;
1258 1440
1259 connectmode = conf_node::C_ALWAYS; // initial setting 1441 // queue a dummy packet to force an initial connection attempt
1442 if (connectmode != conf_node::C_ALWAYS && connectmode != conf_node::C_DISABLED)
1443 vpn_queue.put (new net_packet);
1444
1260 reset_connection (); 1445 reset_connection ();
1261} 1446}
1262 1447
1263connection::~connection () 1448connection::~connection ()
1264{ 1449{
1265 shutdown (); 1450 shutdown ();
1266} 1451}
1267 1452
1453void
1268void connection_init () 1454connection_init ()
1269{ 1455{
1270 auth_rate_limiter.clear (); 1456 auth_rate_limiter.clear ();
1271 reset_rate_limiter.clear (); 1457 reset_rate_limiter.clear ();
1272} 1458}
1273 1459

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines