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

Diff Legend

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