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.69 by pcg, Thu Aug 7 17:54:26 2008 UTC vs.
Revision 1.106 by root, Fri Jul 19 21:01:16 2013 UTC

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

Diff Legend

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