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.65 by pcg, Tue Dec 4 17:17:20 2007 UTC vs.
Revision 1.99 by root, Wed Jul 17 04:36:03 2013 UTC

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

Diff Legend

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