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.66 by pcg, Thu Dec 6 00:35:29 2007 UTC vs.
Revision 1.100 by root, Wed Jul 17 05:34:17 2013 UTC

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

Diff Legend

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