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

Diff Legend

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