[ViewVC] Diff of: cvs/gvpe/src/connection.C

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

Diff Legend

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

Comparing gvpe/src/connection.C (file contents): Revision 1.20 by pcg, Tue Oct 14 15:48:15 2003 UTC vs. Revision 1.106 by root, Fri Jul 19 21:01:16 2013 UTC

Diff Legend

Comparing gvpe/src/connection.C (file contents):
Revision 1.20 by pcg, Tue Oct 14 15:48:15 2003 UTC vs.
Revision 1.106 by root, Fri Jul 19 21:01:16 2013 UTC