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.64 by pcg, Tue Dec 4 15:01:12 2007 UTC vs.
Revision 1.101 by root, Wed Jul 17 16:40:57 2013 UTC

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

Diff Legend

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