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

Diff Legend

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