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.62 by pcg, Sat Dec 1 23:35:31 2007 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 (ev::timer &w, int revents); ev::timer 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 > ev_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.is_active ()) 209 // every use prolongs the expiry
111 cleaner.again ();
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 = ev_now () + RSA_TTL; 210 auth_expire = ev_now () + AUTH_TTL;
124 e.id = id;
125 memcpy (&e.chg, &chg, sizeof chg);
126
127 push_back (e);
128
129 if (!cleaner.is_active ())
130 cleaner.again ();
131 }
132
133 rsa_cache ()
134 : cleaner (this, &rsa_cache::cleaner_cb)
135 {
136 cleaner.set (RSA_TTL, RSA_TTL);
137 }
138
139} rsa_cache;
140
141void rsa_cache::cleaner_cb (ev::timer &w, int revents)
142{
143 if (empty ())
144 w.stop ();
145 else
146 {
147 for (iterator i = begin (); i != end (); )
148 if (i->expire <= ev_now ())
149 i = erase (i);
150 else
151 ++i;
152 }
153} 211}
154 212
155////////////////////////////////////////////////////////////////////////////// 213//////////////////////////////////////////////////////////////////////////////
156 214
157void 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)
158{ 217{
159 if (queue[i]) 218 queue = new pkt [max_queue];
160 {
161 delete queue[i];
162 j = (j + 1) % QUEUEDEPTH;
163 }
164 219
165 queue[i] = p;
166
167 i = (i + 1) % QUEUEDEPTH;
168}
169
170net_packet *pkt_queue::get ()
171{
172 net_packet *p = queue[j];
173
174 if (p)
175 {
176 queue[j] = 0;
177 j = (j + 1) % QUEUEDEPTH;
178 }
179
180 return p;
181}
182
183pkt_queue::pkt_queue ()
184{
185 memset (queue, 0, sizeof (queue));
186 i = 0; 220 i = 0;
187 j = 0; 221 j = 0;
222
223 expire.set<pkt_queue, &pkt_queue::expire_cb> (this);
188} 224}
189 225
190pkt_queue::~pkt_queue () 226pkt_queue::~pkt_queue ()
191{ 227{
192 for (i = QUEUEDEPTH; --i > 0; ) 228 while (net_packet *p = get ())
229 delete p;
230
193 delete queue[i]; 231 delete [] queue;
194} 232}
195 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
196struct net_rateinfo { 290struct net_rateinfo
291{
197 u32 host; 292 u32 host;
198 double pcnt, diff; 293 double pcnt, diff;
199 tstamp last; 294 tstamp last;
200}; 295};
201 296
… …
211 306
212 bool can (const sockinfo &si) { return can((u32)si.host); } 307 bool can (const sockinfo &si) { return can((u32)si.host); }
213 bool can (u32 host); 308 bool can (u32 host);
214}; 309};
215 310
216net_rate_limiter auth_rate_limiter, reset_rate_limiter; 311static net_rate_limiter auth_rate_limiter, reset_rate_limiter;
217 312
313bool
218bool net_rate_limiter::can (u32 host) 314net_rate_limiter::can (u32 host)
219{ 315{
220 iterator i; 316 iterator i;
221 317
222 for (i = begin (); i != end (); ) 318 for (i = begin (); i != end (); )
223 if (i->host == host) 319 if (i->host == host)
… …
270 366
271///////////////////////////////////////////////////////////////////////////// 367/////////////////////////////////////////////////////////////////////////////
272 368
273unsigned char hmac_packet::hmac_digest[EVP_MAX_MD_SIZE]; 369unsigned char hmac_packet::hmac_digest[EVP_MAX_MD_SIZE];
274 370
371void
275void hmac_packet::hmac_gen (crypto_ctx *ctx) 372hmac_packet::hmac_gen (crypto_ctx *ctx)
276{ 373{
277 unsigned int xlen; 374 unsigned int xlen;
278 375
279 HMAC_CTX *hctx = &ctx->hctx; 376 HMAC_CTX *hctx = &ctx->hctx;
280 377
281 HMAC_Init_ex (hctx, 0, 0, 0, 0); 378 require (HMAC_Init_ex (hctx, 0, 0, 0, 0));
282 HMAC_Update (hctx, ((unsigned char *) this) + sizeof (hmac_packet), 379 require (HMAC_Update (hctx, ((unsigned char *) this) + sizeof (hmac_packet),
283 len - sizeof (hmac_packet)); 380 len - sizeof (hmac_packet)));
284 HMAC_Final (hctx, (unsigned char *) &hmac_digest, &xlen); 381 require (HMAC_Final (hctx, (unsigned char *) &hmac_digest, &xlen));
285} 382}
286 383
287void 384void
288hmac_packet::hmac_set (crypto_ctx *ctx) 385hmac_packet::hmac_set (crypto_ctx *ctx)
289{ 386{
… …
298 hmac_gen (ctx); 395 hmac_gen (ctx);
299 396
300 return !memcmp (hmac, hmac_digest, HMACLENGTH); 397 return !memcmp (hmac, hmac_digest, HMACLENGTH);
301} 398}
302 399
400void
303void vpn_packet::set_hdr (ptype type_, unsigned int dst) 401vpn_packet::set_hdr (ptype type_, unsigned int dst)
304{ 402{
305 type = type_; 403 type = type_;
306 404
307 int src = THISNODE->id; 405 int src = THISNODE->id;
308 406
… …
313 411
314#define MAXVPNDATA (MAX_MTU - 6 - 6) 412#define MAXVPNDATA (MAX_MTU - 6 - 6)
315#define DATAHDR (sizeof (u32) + RAND_SIZE) 413#define DATAHDR (sizeof (u32) + RAND_SIZE)
316 414
317struct 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
318 { 424 {
319 u8 data[MAXVPNDATA + DATAHDR]; // seqno
320
321 void setup (connection *conn, int dst, u8 *d, u32 len, u32 seqno);
322 tap_packet *unpack (connection *conn, u32 &seqno);
323private:
324
325 const u32 data_hdr_size () const
326 {
327 return sizeof (vpndata_packet) - sizeof (net_packet) - MAXVPNDATA - DATAHDR; 425 return sizeof (vpndata_packet) - sizeof (net_packet) - MAXVPNDATA - DATAHDR;
328 }
329 }; 426 }
427};
330 428
331void 429void
332vpndata_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)
333{ 431{
334 EVP_CIPHER_CTX *cctx = &conn->octx->cctx; 432 EVP_CIPHER_CTX *cctx = &conn->octx->cctx;
… …
336 ptype type = PT_DATA_UNCOMPRESSED; 434 ptype type = PT_DATA_UNCOMPRESSED;
337 435
338#if ENABLE_COMPRESSION 436#if ENABLE_COMPRESSION
339 u8 cdata[MAX_MTU]; 437 u8 cdata[MAX_MTU];
340 438
341 if (conn->features & ENABLE_COMPRESSION) 439 if (conn->features & FEATURE_COMPRESSION)
342 { 440 {
343 u32 cl = lzf_compress (d, l, cdata + 2, (l - 2) & ~7); 441 u32 cl = lzf_compress (d, l, cdata + 2, (l - 2) & ~7);
344 442
345 if (cl) 443 if (cl)
346 { 444 {
… …
352 d[1] = cl; 450 d[1] = cl;
353 } 451 }
354 } 452 }
355#endif 453#endif
356 454
357 require (EVP_EncryptInit_ex (cctx, 0, 0, 0, 0)); 455 require (EVP_CipherInit_ex (cctx, 0, 0, 0, 0, 1));
358 456
359 struct { 457 struct {
360#if RAND_SIZE 458#if RAND_SIZE
361 u8 rnd[RAND_SIZE]; 459 u8 rnd[RAND_SIZE];
362#endif 460#endif
363 u32 seqno; 461 u32 seqno;
364 } datahdr; 462 } datahdr;
365 463
366 datahdr.seqno = ntohl (seqno); 464 datahdr.seqno = ntohl (seqno);
367#if RAND_SIZE 465#if RAND_SIZE
368 RAND_pseudo_bytes ((unsigned char *) datahdr.rnd, RAND_SIZE); 466 RAND_bytes ((unsigned char *) datahdr.rnd, RAND_SIZE);
369#endif 467#endif
370 468
371 require (EVP_EncryptUpdate (cctx, 469 require (EVP_EncryptUpdate (cctx,
372 (unsigned char *) data + outl, &outl2, 470 (unsigned char *) data + outl, &outl2,
373 (unsigned char *) &datahdr, DATAHDR)); 471 (unsigned char *) &datahdr, DATAHDR));
… …
395 int outl = 0, outl2; 493 int outl = 0, outl2;
396 tap_packet *p = new tap_packet; 494 tap_packet *p = new tap_packet;
397 u8 *d; 495 u8 *d;
398 u32 l = len - data_hdr_size (); 496 u32 l = len - data_hdr_size ();
399 497
400 require (EVP_DecryptInit_ex (cctx, 0, 0, 0, 0)); 498 require (EVP_CipherInit_ex (cctx, 0, 0, 0, 0, 0));
401 499
402#if ENABLE_COMPRESSION 500#if ENABLE_COMPRESSION
403 u8 cdata[MAX_MTU]; 501 u8 cdata[MAX_MTU];
404 502
405 if (type == PT_DATA_COMPRESSED) 503 if (type == PT_DATA_COMPRESSED)
… …
447 } 545 }
448}; 546};
449 547
450struct config_packet : vpn_packet 548struct config_packet : vpn_packet
451{ 549{
452 // actually, hmaclen cannot be checked because the hmac
453 // field comes before this data, so peers with other
454 // hmacs simply will not work.
455 u8 prot_major, prot_minor, randsize, hmaclen; 550 u8 prot_major, prot_minor, randsize;
456 u8 flags, challengelen, features, pad3; 551 u8 flags, features, pad6, pad7, pad8;
457 u32 cipher_nid, digest_nid, hmac_nid; 552 u32 cipher_nid, mac_nid, auth_nid;
458 553
459 void setup (ptype type, int dst); 554 void setup (ptype type, int dst);
460 bool chk_config () const; 555 bool chk_config () const;
461 556
462 static u8 get_features () 557 static u8 get_features ()
… …
473#endif 568#endif
474 return f; 569 return f;
475 } 570 }
476}; 571};
477 572
573void
478void config_packet::setup (ptype type, int dst) 574config_packet::setup (ptype type, int dst)
479{ 575{
480 prot_major = PROTOCOL_MAJOR; 576 prot_major = PROTOCOL_MAJOR;
481 prot_minor = PROTOCOL_MINOR; 577 prot_minor = PROTOCOL_MINOR;
482 randsize = RAND_SIZE; 578 randsize = RAND_SIZE;
483 hmaclen = HMACLENGTH;
484 flags = 0; 579 flags = 0;
485 challengelen = sizeof (rsachallenge);
486 features = get_features (); 580 features = get_features ();
487 581
488 cipher_nid = htonl (EVP_CIPHER_nid (CIPHER)); 582 cipher_nid = htonl (EVP_CIPHER_nid (CIPHER ()));
489 digest_nid = htonl (EVP_MD_type (RSA_HASH));
490 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 ()));
491 585
492 len = sizeof (*this) - sizeof (net_packet); 586 len = sizeof (*this) - sizeof (net_packet);
493 set_hdr (type, dst); 587 set_hdr (type, dst);
494} 588}
495 589
590bool
496bool config_packet::chk_config () const 591config_packet::chk_config () const
497{ 592{
498 if (prot_major != PROTOCOL_MAJOR) 593 if (prot_major != PROTOCOL_MAJOR)
499 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);
500 else if (randsize != RAND_SIZE) 595 else if (randsize != RAND_SIZE)
501 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);
502 else if (hmaclen != HMACLENGTH)
503 slog (L_WARN, _("hmac length mismatch (remote %d <=> local %d)"), hmaclen, HMACLENGTH);
504 else if (challengelen != sizeof (rsachallenge))
505 slog (L_WARN, _("challenge length mismatch (remote %d <=> local %d)"), challengelen, sizeof (rsachallenge));
506 else if (cipher_nid != htonl (EVP_CIPHER_nid (CIPHER))) 597 else if (cipher_nid != htonl (EVP_CIPHER_nid (CIPHER ())))
507 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 ()));
508 else if (digest_nid != htonl (EVP_MD_type (RSA_HASH)))
509 slog (L_WARN, _("digest mismatch (remote %x <=> local %x)"), ntohl (digest_nid), EVP_MD_type (RSA_HASH));
510 else if (hmac_nid != htonl (EVP_MD_type (DIGEST))) 599 else if (mac_nid != htonl (EVP_MD_type (MAC_DIGEST ())))
511 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 ()));
512 else 603 else
513 return true; 604 return true;
514 605
515 return false; 606 return false;
516} 607}
517 608
518struct auth_req_packet : config_packet 609struct auth_req_packet : config_packet // UNPROTECTED
519{ 610{
520 char magic[8]; 611 char magic[8];
521 u8 initiate; // false if this is just an automatic reply 612 u8 initiate; // false if this is just an automatic reply
522 u8 protocols; // supported protocols (will be patched on forward) 613 u8 protocols; // supported protocols (will be patched on forward)
523 u8 pad2, pad3; 614 u8 pad2, pad3;
524 rsaid id; 615 auth_encr encr;
525 rsaencrdata encr;
526 616
527 auth_req_packet (int dst, bool initiate_, u8 protocols_) 617 auth_req_packet (int dst, bool initiate_, u8 protocols_)
528 { 618 {
529 config_packet::setup (PT_AUTH_REQ, dst); 619 config_packet::setup (PT_AUTH_REQ, dst);
530 strncpy (magic, MAGIC, 8); 620 memcpy (magic, MAGIC, 8);
531 initiate = !!initiate_; 621 initiate = !!initiate_;
532 protocols = protocols_; 622 protocols = protocols_;
533 623
534 len = sizeof (*this) - sizeof (net_packet); 624 len = sizeof (*this) - sizeof (net_packet);
535 } 625 }
536}; 626};
537 627
538struct auth_res_packet : config_packet 628struct auth_res_packet : config_packet // UNPROTECTED
539{ 629{
540 rsaid id;
541 u8 pad1, pad2, pad3;
542 u8 response_len; // encrypted length
543 rsaresponse response; 630 auth_response response;
544 631
545 auth_res_packet (int dst) 632 auth_res_packet (int dst)
546 { 633 {
547 config_packet::setup (PT_AUTH_RES, dst); 634 config_packet::setup (PT_AUTH_RES, dst);
548 635
… …
582}; 669};
583 670
584///////////////////////////////////////////////////////////////////////////// 671/////////////////////////////////////////////////////////////////////////////
585 672
586void 673void
587connection::connection_established () 674connection::connection_established (const sockinfo &rsi)
588{ 675{
589 slog (L_TRACE, _("%s: possible connection establish (ictx %d, octx %d)"), conf->nodename, !!ictx, !!octx); 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;
590 699
591 if (ictx && octx) 700 if (ictx && octx)
592 { 701 {
593 connectmode = conf->connectmode;
594
595 // make sure rekeying timeouts are slightly asymmetric 702 // make sure rekeying timeouts are slightly asymmetric
596 ev::tstamp rekey_interval = ::conf.rekey + (conf->id > THISNODE->id ? 10 : 0); 703 ev::tstamp rekey_interval = ::conf.rekey + (conf->id > THISNODE->id ? 10 : 0);
597 rekey.start (rekey_interval, rekey_interval); 704 rekey.start (rekey_interval, rekey_interval);
705
598 keepalive.start (::conf.keepalive); 706 keepalive.start (::conf.keepalive);
599 707
600 // send queued packets 708 // send queued packets
601 if (ictx && octx) 709 if (ictx && octx)
602 { 710 {
603 while (tap_packet *p = (tap_packet *)data_queue.get ()) 711 while (tap_packet *p = (tap_packet *)data_queue.get ())
604 { 712 {
605 send_data_packet (p); 713 if (p->len) send_data_packet (p);
606 delete p; 714 delete p;
607 } 715 }
608 716
609 while (vpn_packet *p = (vpn_packet *)vpn_queue.get ()) 717 while (vpn_packet *p = (vpn_packet *)vpn_queue.get ())
610 { 718 {
611 send_vpn_packet (p, si, IPTOS_RELIABILITY); 719 if (p->len) send_vpn_packet (p, si, IPTOS_RELIABILITY);
612 delete p; 720 delete p;
613 } 721 }
614 } 722 }
723
724 vpn->connection_established (this);
615 } 725 }
726#if 0
616 else 727 else
617 { 728 {
618 retry_cnt = 0; 729 retry_cnt = 0;
619 establish_connection.start (5); 730 establish_connection.start (5);
620 keepalive.stop (); 731 keepalive.stop ();
621 rekey.stop (); 732 rekey.stop ();
622 } 733 }
734#endif
623} 735}
624 736
625void 737void
626connection::reset_si () 738connection::reset_si ()
627{ 739{
740 if (vpn->can_direct (THISNODE, conf))
628 protocol = best_protocol (THISNODE->protocols & conf->protocols); 741 protocol = best_protocol (THISNODE->protocols & conf->connectable_protocols ());
629 742 else
630 // mask out protocols we cannot establish
631 if (!conf->udp_port) protocol &= ~PROT_UDPv4;
632 if (!conf->tcp_port) protocol &= ~PROT_TCPv4;
633 if (!conf->dns_port) protocol &= ~PROT_DNSv4;
634
635 if (protocol
636 && (!conf->can_direct (THISNODE)
637 || !THISNODE->can_direct (conf)))
638 { 743 {
639 slog (L_DEBUG, _("%s: direct connection denied"), conf->nodename); 744 slog (L_TRACE, _("%s: direct connection denied by config."), conf->nodename);
640 protocol = 0; 745 protocol = 0;
641 } 746 }
642 747
643 si.set (conf, protocol); 748 si.set (conf, protocol);
749
750 is_direct = si.valid ();
644} 751}
645 752
646// ensure sockinfo is valid, forward if necessary 753// ensure sockinfo is valid, forward if necessary
647const sockinfo & 754const sockinfo &
648connection::forward_si (const sockinfo &si) const 755connection::forward_si (const sockinfo &si) const
649{ 756{
650 if (!si.valid ()) 757 if (!si.valid ())
651 { 758 {
652 connection *r = vpn->find_router (); 759 connection *r = vpn->find_router_for (this);
653 760
654 if (r) 761 if (r)
655 { 762 {
656 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."),
657 conf->nodename, r->conf->nodename, (const char *)r->si); 764 conf->nodename, r->conf->nodename);
658 return r->si; 765 return r->si;
659 } 766 }
660 else 767 else
661 slog (L_DEBUG, _("%s: node unreachable, no common protocol"), 768 slog (L_DEBUG, _("%s: node unreachable, no common protocol or no router available."),
662 conf->nodename); 769 conf->nodename);
663 } 770 }
664 771
665 return si; 772 return si;
666} 773}
… …
676connection::send_ping (const sockinfo &si, u8 pong) 783connection::send_ping (const sockinfo &si, u8 pong)
677{ 784{
678 ping_packet *pkt = new ping_packet; 785 ping_packet *pkt = new ping_packet;
679 786
680 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);
681 send_vpn_packet (pkt, si, IPTOS_LOWDELAY); 790 send_vpn_packet (pkt, si, IPTOS_LOWDELAY);
682 791
683 delete pkt; 792 delete pkt;
684} 793}
685 794
… …
700void 809void
701connection::send_auth_request (const sockinfo &si, bool initiate) 810connection::send_auth_request (const sockinfo &si, bool initiate)
702{ 811{
703 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);
704 813
705 rsachallenge chg; 814 generate_auth_data ();
706 rsa_cache.gen (pkt->id, chg);
707 rsa_encrypt (conf->rsa_key, chg, pkt->encr); 815 auth_encrypt (conf->rsa_key, snd_auth, pkt->encr);
708 816
709 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);
710
711 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
712 819
713 delete pkt; 820 delete pkt;
714} 821}
715 822
716void 823void
717connection::send_auth_response (const sockinfo &si, const rsaid &id, const rsachallenge &chg) 824connection::send_auth_response (const sockinfo &si)
718{ 825{
719 auth_res_packet *pkt = new auth_res_packet (conf->id); 826 auth_res_packet *pkt = new auth_res_packet (conf->id);
720 827
721 pkt->id = id; 828 auth_hash (rcv_auth, pkt->response.mac);
829 memcpy (pkt->response.ecdh, rcv_ecdh_b, sizeof (rcv_ecdh_b));
722 830
723 rsa_hash (id, chg, pkt->response);
724
725 pkt->hmac_set (octx);
726
727 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);
728
729 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
730 833
731 delete pkt; 834 delete pkt;
732} 835}
733 836
734void 837void
735connection::send_connect_info (int rid, const sockinfo &rsi, u8 rprotocols) 838connection::send_connect_info (int rid, const sockinfo &rsi, u8 rprotocols)
736{ 839{
737 slog (L_TRACE, ">>%d PT_CONNECT_INFO(%d,%s)", 840 slog (L_TRACE, "%s << PT_CONNECT_INFO(%s,%s,p%02x)", conf->nodename,
738 conf->id, rid, (const char *)rsi); 841 vpn->conns[rid - 1]->conf->nodename, (const char *)rsi,
842 conf->protocols);
739 843
740 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);
741 845
742 r->hmac_set (octx); 846 r->hmac_set (octx);
743 send_vpn_packet (r, si); 847 send_vpn_packet (r, si);
744 848
745 delete r; 849 delete r;
746} 850}
747 851
748void 852inline void
749connection::establish_connection_cb (ev::timer &w, int revents) 853connection::establish_connection_cb (ev::timer &w, int revents)
750{ 854{
751 if (!ictx 855 if (!(ictx && octx)
752 && conf != THISNODE 856 && conf != THISNODE
753 && connectmode != conf_node::C_NEVER 857 && connectmode != conf_node::C_NEVER
754 && connectmode != conf_node::C_DISABLED 858 && connectmode != conf_node::C_DISABLED
755 && !w.is_active ()) 859 && !w.is_active ())
756 { 860 {
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 }
868
869 last_establish_attempt = ev_now ();
870
757 ev::tstamp retry_int = ev::tstamp (retry_cnt & 3 871 ev::tstamp retry_int = ev::tstamp (retry_cnt & 3
758 ? (retry_cnt & 3) + 1 872 ? (retry_cnt & 3) + 1
759 : 1 << (retry_cnt >> 2)); 873 : 1 << (retry_cnt >> 2));
760 874
761 reset_si (); 875 reset_si ();
762 876
763 bool slow = si.prot & PROT_SLOW; 877 bool slow = si.prot & PROT_SLOW;
764 878
765 if (si.prot && !si.host) 879 if (si.prot && !si.host && vpn->can_direct (THISNODE, conf))
766 { 880 {
767 slog (L_TRACE, _("%s: connection request (indirect)"), conf->nodename);
768 /*TODO*/ /* start the timer so we don't recurse endlessly */ 881 /*TODO*/ /* start the timer so we don't recurse endlessly */
769 w.start (1); 882 w.start (1);
770 vpn->send_connect_request (conf->id); 883 vpn->send_connect_request (this);
771 } 884 }
772 else 885 else
773 { 886 {
774 slog (L_TRACE, _("%s: connection request (direct)"), conf->nodename, !!ictx, !!octx); 887 if (si.valid ())
888 slog (L_DEBUG, _("%s: sending direct connection request to %s."),
889 conf->nodename, (const char *)si);
775 890
776 const sockinfo &dsi = forward_si (si); 891 const sockinfo &dsi = forward_si (si);
777 892
778 slow = slow || (dsi.prot & PROT_SLOW); 893 slow = slow || (dsi.prot & PROT_SLOW);
779 894
… …
784 else 899 else
785 send_ping (dsi, 0); 900 send_ping (dsi, 0);
786 } 901 }
787 } 902 }
788 903
789 retry_int *= slow ? 8. : 0.7; 904 retry_int *= slow ? 8. : 0.9;
790 905
791 if (retry_int < conf->max_retry) 906 if (retry_int < conf->max_retry)
792 retry_cnt++; 907 retry_cnt++;
793 else 908 else
794 retry_int = conf->max_retry; 909 retry_int = conf->max_retry;
… …
804 { 919 {
805 slog (L_INFO, _("%s(%s): connection lost"), 920 slog (L_INFO, _("%s(%s): connection lost"),
806 conf->nodename, (const char *)si); 921 conf->nodename, (const char *)si);
807 922
808 if (::conf.script_node_down) 923 if (::conf.script_node_down)
809 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);
810 slog (L_WARN, _("node-down command execution failed, continuing.")); 927 run_script_queued (cb, _("node-down command execution failed, continuing."));
928 }
811 } 929 }
812 930
813 delete ictx; ictx = 0; 931 delete ictx; ictx = 0;
814 delete octx; octx = 0; 932 delete octx; octx = 0;
815#if ENABLE_DNS
816 dnsv4_reset_connection ();
817#endif
818 933
819 si.host = 0; 934 si.host = 0;
820 935
936 have_snd_auth = false;
937 have_rcv_auth = false;
938 auth_expire = 0.;
939
821 last_activity = 0; 940 last_activity = 0.;
941 //last_si_change = 0.;
822 retry_cnt = 0; 942 retry_cnt = 0;
823 943
824 rekey.stop (); 944 rekey.stop ();
825 keepalive.stop (); 945 keepalive.stop ();
826 establish_connection.stop (); 946 establish_connection.stop ();
… …
833 send_reset (si); 953 send_reset (si);
834 954
835 reset_connection (); 955 reset_connection ();
836} 956}
837 957
838void 958// poor-man's rekeying
959inline void
839connection::rekey_cb (ev::timer &w, int revents) 960connection::rekey_cb (ev::timer &w, int revents)
840{ 961{
841 reset_connection (); 962 reset_connection ();
842 establish_connection (); 963 establish_connection ();
843} 964}
… …
860 if (oseqno > MAX_SEQNO) 981 if (oseqno > MAX_SEQNO)
861 rekey (); 982 rekey ();
862} 983}
863 984
864void 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
865connection::inject_data_packet (tap_packet *pkt, bool broadcast/*TODO DDD*/) 996connection::inject_data_packet (tap_packet *pkt)
866{ 997{
867 if (ictx && octx) 998 if (ictx && octx)
868 send_data_packet (pkt); 999 send_data_packet (pkt);
869 else 1000 else
870 { 1001 {
871 if (!broadcast)
872 data_queue.put (new tap_packet (*pkt)); 1002 data_queue.put (new tap_packet (*pkt));
873 1003 post_inject_queue ();
874 establish_connection ();
875 } 1004 }
876} 1005}
877 1006
1007void
878void connection::inject_vpn_packet (vpn_packet *pkt, int tos) 1008connection::inject_vpn_packet (vpn_packet *pkt, int tos)
879{ 1009{
880 if (ictx && octx) 1010 if (ictx && octx)
881 send_vpn_packet (pkt, si, tos); 1011 send_vpn_packet (pkt, si, tos);
882 else 1012 else
883 { 1013 {
884 vpn_queue.put ((vpn_packet *)new data_packet (*(data_packet *)pkt)); 1014 vpn_queue.put ((vpn_packet *)new data_packet (*(data_packet *)pkt));
885 1015 post_inject_queue ();
886 establish_connection ();
887 } 1016 }
888} 1017}
889 1018
890void 1019void
891connection::recv_vpn_packet (vpn_packet *pkt, const sockinfo &rsi) 1020connection::recv_vpn_packet (vpn_packet *pkt, const sockinfo &rsi)
892{ 1021{
893 last_activity = ev_now (); 1022 last_activity = ev_now ();
894 1023
895 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.",
896 conf->id, pkt->typ (), pkt->src (), pkt->dst ()); 1025 conf->nodename, pkt->typ (), pkt->src (), pkt->dst ());
897 1026
898 if (connectmode == conf_node::C_DISABLED) 1027 if (connectmode == conf_node::C_DISABLED)
899 return; 1028 return;
900 1029
901 switch (pkt->typ ()) 1030 switch (pkt->typ ())
902 { 1031 {
903 case vpn_packet::PT_PING: 1032 case vpn_packet::PT_PING:
1033 slog (L_TRACE, "%s >> PT_PING", conf->nodename);
1034
904 // we send pings instead of auth packets after some retries, 1035 // we send pings instead of auth packets after some retries,
905 // so reset the retry counter and establish a connection 1036 // so reset the retry counter and establish a connection
906 // when we receive a ping. 1037 // when we receive a ping.
907 if (!ictx) 1038 if (!ictx)
908 { 1039 {
909 if (auth_rate_limiter.can (rsi)) 1040 if (auth_rate_limiter.can (rsi))
910 send_auth_request (rsi, true); 1041 send_auth_request (rsi, true);
911 } 1042 }
912 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.
913 send_ping (rsi, 1); // pong 1046 send_ping (rsi, 1); // pong
914 1047
915 break; 1048 break;
916 1049
917 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 ();
918 break; 1056 break;
919 1057
920 case vpn_packet::PT_RESET: 1058 case vpn_packet::PT_RESET:
921 { 1059 {
922 reset_connection (); 1060 reset_connection ();
923 1061
924 config_packet *p = (config_packet *) pkt; 1062 config_packet *p = (config_packet *) pkt;
925 1063
926 if (!p->chk_config ()) 1064 if (!p->chk_config ())
927 { 1065 {
928 slog (L_WARN, _("%s(%s): protocol mismatch, disabling node"), 1066 slog (L_WARN, _("%s(%s): protocol mismatch, disabling node."),
929 conf->nodename, (const char *)rsi); 1067 conf->nodename, (const char *)rsi);
930 connectmode = conf_node::C_DISABLED; 1068 connectmode = conf_node::C_DISABLED;
931 } 1069 }
932 else if (connectmode == conf_node::C_ALWAYS) 1070 else if (connectmode == conf_node::C_ALWAYS)
933 establish_connection (); 1071 establish_connection ();
… …
935 break; 1073 break;
936 1074
937 case vpn_packet::PT_AUTH_REQ: 1075 case vpn_packet::PT_AUTH_REQ:
938 if (auth_rate_limiter.can (rsi)) 1076 if (auth_rate_limiter.can (rsi))
939 { 1077 {
940 auth_req_packet *p = (auth_req_packet *) pkt; 1078 auth_req_packet *p = (auth_req_packet *)pkt;
941 1079
942 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);
943 1083
944 if (p->chk_config () && !strncmp (p->magic, MAGIC, 8)) 1084 if (p->chk_config () && !memcmp (p->magic, MAGIC, 8))
945 { 1085 {
946 if (p->prot_minor != PROTOCOL_MINOR) 1086 if (p->prot_minor != PROTOCOL_MINOR)
947 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."),
948 conf->nodename, (const char *)rsi, 1088 conf->nodename, (const char *)rsi,
949 PROTOCOL_MINOR, conf->nodename, p->prot_minor); 1089 PROTOCOL_MINOR, conf->nodename, p->prot_minor);
950 1090
951 if (p->initiate) 1091 if (p->initiate)
952 send_auth_request (rsi, false); 1092 send_auth_request (rsi, false);
953 1093
954 rsachallenge k; 1094 auth_data auth;
955 1095
956 if (!rsa_decrypt (::conf.rsa_key, p->encr, k)) 1096 if (!auth_decrypt (::conf.rsa_key, p->encr, auth))
957 { 1097 {
958 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?"),
959 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));
960 break;
961 } 1100 }
962 else 1101 else
963 { 1102 {
964 delete octx; 1103 bool chg = !have_rcv_auth || memcmp (&rcv_auth, &auth, sizeof auth);
965 1104
966 octx = new crypto_ctx (k, 1); 1105 rcv_auth = auth;
967 oseqno = ntohl (*(u32 *)&k[CHG_SEQNO]) & 0x7fffffff; 1106 have_rcv_auth = true;
968 1107
1108 send_auth_response (rsi);
1109
1110 if (chg)
1111 {
969 conf->protocols = p->protocols; 1112 conf->protocols = p->protocols;
970 features = p->features & config_packet::get_features (); 1113 features = p->features & config_packet::get_features ();
971 1114
972 send_auth_response (rsi, p->id, k);
973
974 connection_established (); 1115 connection_established (rsi);
975
976 break; 1116 }
977 } 1117 }
1118
1119 break;
978 } 1120 }
979 else 1121 else
980 slog (L_WARN, _("%s(%s): protocol mismatch"), 1122 slog (L_WARN, _("%s(%s): protocol mismatch."),
981 conf->nodename, (const char *)rsi); 1123 conf->nodename, (const char *)rsi);
982 1124
983 send_reset (rsi); 1125 send_reset (rsi);
984 } 1126 }
985 1127
986 break; 1128 break;
987 1129
988 case vpn_packet::PT_AUTH_RES: 1130 case vpn_packet::PT_AUTH_RES:
989 { 1131 {
990 auth_res_packet *p = (auth_res_packet *) pkt; 1132 auth_res_packet *p = (auth_res_packet *)pkt;
991 1133
992 slog (L_TRACE, "<<%d PT_AUTH_RES", conf->id); 1134 slog (L_TRACE, "%s >> PT_AUTH_RES", conf->nodename);
993 1135
994 if (p->chk_config ()) 1136 if (p->chk_config ())
995 { 1137 {
996 if (p->prot_minor != PROTOCOL_MINOR) 1138 if (memcmp (&p->response.mac, snd_auth_mac, sizeof (snd_auth_mac)))
997 slog (L_INFO, _("%s(%s): protocol minor version mismatch: ours is %d, %s's is %d."),
998 conf->nodename, (const char *)rsi,
999 PROTOCOL_MINOR, conf->nodename, p->prot_minor);
1000
1001 rsachallenge chg;
1002
1003 if (!rsa_cache.find (p->id, chg))
1004 { 1139 {
1005 slog (L_ERR, _("%s(%s): unrequested auth response ignored"), 1140 slog (L_ERR, _("%s(%s): unrequested or outdated auth response, ignoring."),
1006 conf->nodename, (const char *)rsi); 1141 conf->nodename, (const char *)rsi);
1007 break;
1008 } 1142 }
1009 else 1143 else if (!have_snd_auth)
1010 { 1144 {
1011 crypto_ctx *cctx = new crypto_ctx (chg, 0); 1145 if (p->prot_minor != PROTOCOL_MINOR)
1012 1146 slog (L_INFO, _("%s(%s): protocol minor version mismatch: ours is %d, %s's is %d."),
1013 if (!p->hmac_chk (cctx))
1014 {
1015 slog (L_ERR, _("%s(%s): hmac authentication error on auth response, received invalid packet\n"
1016 "could be an attack, or just corruption or a synchronization error"),
1017 conf->nodename, (const char *)rsi); 1147 conf->nodename, (const char *)rsi,
1018 break; 1148 PROTOCOL_MINOR, conf->nodename, p->prot_minor);
1019 }
1020 else
1021 {
1022 rsaresponse h;
1023 1149
1024 rsa_hash (p->id, chg, h);
1025
1026 if (!memcmp ((u8 *)&h, (u8 *)p->response, sizeof h))
1027 {
1028 prot_minor = p->prot_minor; 1150 prot_minor = p->prot_minor;
1151 memcpy (snd_ecdh_b, p->response.ecdh, sizeof (snd_ecdh_b));
1029 1152
1030 delete ictx; ictx = cctx; 1153 have_snd_auth = true;
1031
1032 iseqno.reset (ntohl (*(u32 *)&chg[CHG_SEQNO]) & 0x7fffffff); // at least 2**31 sequence numbers are valid
1033
1034 si = rsi;
1035 protocol = rsi.prot;
1036
1037 connection_established (); 1154 connection_established (rsi);
1038
1039 slog (L_INFO, _("%s(%s): connection established, protocol version %d.%d"),
1040 conf->nodename, (const char *)rsi,
1041 p->prot_major, p->prot_minor);
1042
1043 if (::conf.script_node_up)
1044 if (!run_script (run_script_cb (this, &connection::script_node_up), false))
1045 slog (L_WARN, _("node-up command execution failed, continuing."));
1046
1047 break;
1048 }
1049 else
1050 slog (L_ERR, _("%s(%s): sent and received challenge do not match"),
1051 conf->nodename, (const char *)rsi);
1052 }
1053
1054 delete cctx;
1055 } 1155 }
1156
1157 break;
1056 } 1158 }
1057 } 1159 }
1058 1160
1059 send_reset (rsi); 1161 send_reset (rsi);
1060 break; 1162 break;
… …
1071 { 1173 {
1072 vpndata_packet *p = (vpndata_packet *)pkt; 1174 vpndata_packet *p = (vpndata_packet *)pkt;
1073 1175
1074 if (!p->hmac_chk (ictx)) 1176 if (!p->hmac_chk (ictx))
1075 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"
1076 "could be an attack, or just corruption or a synchronization error"), 1178 "could be an attack, or just corruption or a synchronization error."),
1077 conf->nodename, (const char *)rsi); 1179 conf->nodename, (const char *)rsi);
1078 else 1180 else
1079 { 1181 {
1080 u32 seqno; 1182 u32 seqno;
1081 tap_packet *d = p->unpack (this, seqno); 1183 tap_packet *d = p->unpack (this, seqno);
1184 int seqclass = iseqno.seqno_classify (seqno);
1082 1185
1083 if (iseqno.recv_ok (seqno)) 1186 if (seqclass == 0) // ok
1084 { 1187 {
1085 vpn->tap->send (d); 1188 vpn->tap->send (d);
1086 1189
1087 if (si != rsi) 1190 if (si != rsi)
1088 { 1191 {
1089 // 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.)
1090 si = rsi; 1194 // {
1091
1092 slog (L_INFO, _("%s(%s): socket address changed to %s"), 1195 slog (L_INFO, _("%s(%s): changing socket address to %s."),
1093 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);
1094 } 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);
1095 } 1224 }
1096 1225
1097 delete d; 1226 delete d;
1098 break; 1227 break;
1099 } 1228 }
… …
1103 break; 1232 break;
1104 1233
1105 case vpn_packet::PT_CONNECT_REQ: 1234 case vpn_packet::PT_CONNECT_REQ:
1106 if (ictx && octx && rsi == si && pkt->hmac_chk (ictx)) 1235 if (ictx && octx && rsi == si && pkt->hmac_chk (ictx))
1107 { 1236 {
1108 connect_req_packet *p = (connect_req_packet *) pkt; 1237 connect_req_packet *p = (connect_req_packet *)pkt;
1109 1238
1110 if (p->id > 0 && p->id <= vpn->conns.size ()) 1239 if (p->id > 0 && p->id <= vpn->conns.size ())
1111 { 1240 {
1112 connection *c = vpn->conns[p->id - 1]; 1241 connection *c = vpn->conns[p->id - 1];
1113 conf->protocols = p->protocols; 1242 conf->protocols = p->protocols;
1114 1243
1115 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,
1116 conf->id, p->id, c->ictx && c->octx); 1247 c->ictx && c->octx);
1117 1248
1118 if (c->ictx && c->octx) 1249 if (c->ictx && c->octx)
1119 { 1250 {
1120 // send connect_info packets to both sides, in case one is 1251 // send connect_info packets to both sides, in case one is
1121 // behind a nat firewall (or both ;) 1252 // behind a nat firewall (or both ;)
… …
1144 1275
1145 c->conf->protocols = p->protocols; 1276 c->conf->protocols = p->protocols;
1146 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));
1147 p->si.upgrade_protocol (protocol, c->conf); 1278 p->si.upgrade_protocol (protocol, c->conf);
1148 1279
1149 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]",
1150 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);
1151 1288
1152 const sockinfo &dsi = forward_si (p->si); 1289 const sockinfo &dsi = forward_si (p->si);
1153 1290
1154 if (dsi.valid ()) 1291 if (dsi.valid ())
1155 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);
1156 } 1297 }
1157 else 1298 else
1158 slog (L_WARN, 1299 slog (L_WARN,
1159 _("received authenticated connection request from unknown node #%d, config file mismatch?"), 1300 _("received authenticated connection request from unknown node #%d, config file mismatch?"),
1160 p->id); 1301 p->id);
… …
1166 send_reset (rsi); 1307 send_reset (rsi);
1167 break; 1308 break;
1168 } 1309 }
1169} 1310}
1170 1311
1312inline void
1171void connection::keepalive_cb (ev::timer &w, int revents) 1313connection::keepalive_cb (ev::timer &w, int revents)
1172{ 1314{
1173 if (ev_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)
1174 { 1320 {
1175 reset_connection (); 1321 reset_connection ();
1176 establish_connection (); 1322 establish_connection ();
1177 } 1323 }
1178 else if (ev_now () < last_activity + ::conf.keepalive)
1179 w.start (last_activity + ::conf.keepalive - ev::now ());
1180 else if (conf->connectmode != conf_node::C_ONDEMAND 1324 else if (conf->connectmode != conf_node::C_ONDEMAND
1181 || THISNODE->connectmode != conf_node::C_ONDEMAND) 1325 || THISNODE->connectmode != conf_node::C_ONDEMAND)
1182 { 1326 {
1327 w.start (3);
1183 send_ping (si); 1328 send_ping (si);
1184 w.start (5);
1185 } 1329 }
1186 else if (ev_now () < last_activity + ::conf.keepalive + 10) 1330 else if (when >= -10)
1187 // hold ondemand connections implicitly a few seconds longer 1331 // hold ondemand connections implicitly a few seconds longer
1188 // should delete octx, though, or something like that ;) 1332 // should delete octx, though, or something like that ;)
1189 w.start (last_activity + ::conf.keepalive + 10 - ev::now ()); 1333 w.start (when + 10);
1190 else 1334 else
1191 reset_connection (); 1335 reset_connection ();
1192} 1336}
1193 1337
1338void
1194void connection::send_connect_request (int id) 1339connection::send_connect_request (int id)
1195{ 1340{
1196 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);
1197 1342
1198 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);
1199 p->hmac_set (octx); 1346 p->hmac_set (octx);
1200 send_vpn_packet (p, si); 1347 send_vpn_packet (p, si);
1201 1348
1202 delete p; 1349 delete p;
1203} 1350}
1204 1351
1352void
1205void connection::script_init_env (const char *ext) 1353connection::script_init_env (const char *ext)
1206{ 1354{
1207 char *env; 1355 char *env;
1208 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);
1209 asprintf (&env, "NODENAME%s=%s", ext, conf->nodename); putenv (env); 1357 asprintf (&env, "NODENAME%s=%s", ext, conf->nodename); putenv (env);
1210 asprintf (&env, "MAC%s=%02x:%02x:%02x:%02x:%02x:%02x", ext, 1358 asprintf (&env, "MAC%s=%02x:%02x:%02x:%02x:%02x:%02x", ext,
1211 0xfe, 0xfd, 0x80, 0x00, conf->id >> 8, 1359 0xfe, 0xfd, 0x80, 0x00, conf->id >> 8,
1212 conf->id & 0xff); putenv (env); 1360 conf->id & 0xff); putenv (env);
1213} 1361}
1214 1362
1363void
1215void connection::script_init_connect_env () 1364connection::script_init_connect_env ()
1216{ 1365{
1217 vpn->script_init_env (); 1366 vpn->script_init_env ();
1218 1367
1219 char *env; 1368 char *env;
1220 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);
1221 asprintf (&env, "DESTNODE=%s", conf->nodename); putenv (env); 1371 asprintf (&env, "DESTNODE=%s", conf->nodename); putenv (env);
1222 asprintf (&env, "DESTIP=%s", si.ntoa ()); putenv (env); 1372 asprintf (&env, "DESTIP=%s", si.ntoa ()); putenv (env);
1223 asprintf (&env, "DESTPORT=%d", ntohs (si.port)); putenv (env); 1373 asprintf (&env, "DESTPORT=%d", ntohs (si.port)); putenv (env);
1224} 1374}
1225 1375
1376inline const char *
1226const char *connection::script_node_up () 1377connection::script_node_up ()
1227{ 1378{
1228 script_init_connect_env (); 1379 script_init_connect_env ();
1229 1380
1230 putenv ((char *)"STATE=up"); 1381 putenv ((char *)"STATE=up");
1231 1382
… …
1236 ::conf.script_node_up ? ::conf.script_node_up : "node-up"); 1387 ::conf.script_node_up ? ::conf.script_node_up : "node-up");
1237 1388
1238 return filename; 1389 return filename;
1239} 1390}
1240 1391
1392inline const char *
1393connection::script_node_change ()
1394{
1395 script_init_connect_env ();
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 *
1241const char *connection::script_node_down () 1409connection::script_node_down ()
1242{ 1410{
1243 script_init_connect_env (); 1411 script_init_connect_env ();
1244 1412
1245 putenv ((char *)"STATE=down"); 1413 putenv ((char *)"STATE=down");
1246 1414
… …
1252 1420
1253 return filename; 1421 return filename;
1254} 1422}
1255 1423
1256connection::connection (struct vpn *vpn, conf_node *conf) 1424connection::connection (struct vpn *vpn, conf_node *conf)
1257: vpn(vpn), conf(conf) 1425: vpn(vpn), conf(conf),
1258, rekey (this, &connection::rekey_cb)
1259, keepalive (this, &connection::keepalive_cb)
1260, establish_connection (this, &connection::establish_connection_cb)
1261#if ENABLE_DNS 1426#if ENABLE_DNS
1262, dns (0) 1427 dns (0),
1263#endif 1428#endif
1429 data_queue(conf->max_ttl, conf->max_queue + 1),
1430 vpn_queue(conf->max_ttl, conf->max_queue + 1)
1264{ 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.;
1265 octx = ictx = 0; 1437 octx = ictx = 0;
1266 retry_cnt = 0;
1267 1438
1268 if (!conf->protocols) // make sure some protocol is enabled 1439 connectmode = conf->connectmode;
1269 conf->protocols = PROT_UDPv4;
1270 1440
1271 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
1272 reset_connection (); 1445 reset_connection ();
1273} 1446}
1274 1447
1275connection::~connection () 1448connection::~connection ()
1276{ 1449{
1277 shutdown (); 1450 shutdown ();
1278} 1451}
1279 1452
1453void
1280void connection_init () 1454connection_init ()
1281{ 1455{
1282 auth_rate_limiter.clear (); 1456 auth_rate_limiter.clear ();
1283 reset_rate_limiter.clear (); 1457 reset_rate_limiter.clear ();
1284} 1458}
1285 1459

Diff Legend

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