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

Comparing gvpe/src/protocol.C (file contents):
Revision 1.16 by pcg, Tue Mar 25 18:11:58 2003 UTC vs.
Revision 1.19 by pcg, Wed Mar 26 14:39:52 2003 UTC

…		…
58		58
59	static time_t next_timecheck;	59	static time_t next_timecheck;
60		60
61	#define MAGIC "vped\xbd\xc6\xdb\x82" // 8 bytes of magic	61	#define MAGIC "vped\xbd\xc6\xdb\x82" // 8 bytes of magic
62		62
63	static const rsachallenge &	63	struct crypto_ctx
64	challenge_bytes ()
65	{
66	static rsachallenge challenge;
67	static tstamp challenge_ttl; // time this challenge needs to be recreated
68
69	if (NOW > challenge_ttl)
70	{	64	{
71	RAND_bytes ((unsigned char *)&challenge, sizeof (challenge));	65	EVP_CIPHER_CTX cctx;
72	challenge_ttl = NOW + CHALLENGE_TTL;	66	HMAC_CTX hctx;
73	}
74		67
75	return challenge;	68	crypto_ctx (const rsachallenge &challenge, int enc);
76	}	69	~crypto_ctx ();
		70	};
77		71
78	// caching of rsa operations really helps slow computers	72	crypto_ctx::crypto_ctx (const rsachallenge &challenge, int enc)
		73	{
		74	EVP_CIPHER_CTX_init (&cctx);
		75	EVP_CipherInit_ex (&cctx, CIPHER, 0, &challenge[CHG_CIPHER_KEY], 0, enc);
		76	HMAC_CTX_init (&hctx);
		77	HMAC_Init_ex (&hctx, &challenge[CHG_HMAC_KEY], HMAC_KEYLEN, DIGEST, 0);
		78	}
		79
		80	crypto_ctx::~crypto_ctx ()
		81	{
		82	EVP_CIPHER_CTX_cleanup (&cctx);
		83	HMAC_CTX_cleanup (&hctx);
		84	}
		85
		86	static void
		87	rsa_hash (const rsaid &id, const rsachallenge &chg, rsaresponse &h)
		88	{
		89	EVP_MD_CTX ctx;
		90
		91	EVP_MD_CTX_init (&ctx);
		92	EVP_DigestInit (&ctx, RSA_HASH);
		93	EVP_DigestUpdate(&ctx, &chg, sizeof chg);
		94	EVP_DigestUpdate(&ctx, &id, sizeof id);
		95	EVP_DigestFinal (&ctx, (unsigned char *)&h, 0);
		96	EVP_MD_CTX_cleanup (&ctx);
		97	}
		98
79	struct rsa_entry {	99	struct rsa_entry {
80	tstamp expire;	100	tstamp expire;
		101	rsaid id;
81	rsachallenge chg;	102	rsachallenge chg;
82	RSA *key; // which key
83	rsaencrdata encr;
84
85	rsa_entry ()
86	{
87	expire = NOW + CHALLENGE_TTL;
88	}
89	};	103	};
90		104
91	struct rsa_cache : list<rsa_entry>	105	struct rsa_cache : list<rsa_entry>
92	{	106	{
93	void cleaner_cb (tstamp &ts); time_watcher cleaner;	107	void cleaner_cb (tstamp &ts); time_watcher cleaner;
94		108
95	const rsaencrdata public_encrypt (RSA key, const rsachallenge &chg)	109	bool find (const rsaid &id, rsachallenge &chg)
96	{	110	{
97	for (iterator i = begin (); i != end (); ++i)	111	for (iterator i = begin (); i != end (); ++i)
98	{	112	{
99	if (i->key == key && !memcmp (&chg, &i->chg, sizeof chg))	113	if (!memcmp (&id, &i->id, sizeof id) && i->expire > NOW)
100	return &i->encr;	114	{
		115	memcpy (&chg, &i->chg, sizeof chg);
		116
		117	erase (i);
		118	return true;
		119	}
101	}	120	}
102		121
103	if (cleaner.at < NOW)	122	if (cleaner.at < NOW)
104	cleaner.start (NOW + CHALLENGE_TTL);	123	cleaner.start (NOW + RSA_TTL);
105		124
106	resize (size () + 1);	125	return false;
107	rsa_entry e = &(rbegin ());	126	}
108		127
109	e->key = key;	128	void gen (rsaid &id, rsachallenge &chg)
		129	{
		130	rsa_entry e;
		131
		132	RAND_bytes ((unsigned char *)&id, sizeof id);
		133	RAND_bytes ((unsigned char *)&chg, sizeof chg);
		134
		135	e.expire = NOW + RSA_TTL;
		136	e.id = id;
110	memcpy (&e->chg, &chg, sizeof chg);	137	memcpy (&e.chg, &chg, sizeof chg);
111		138
112	if (0 > RSA_public_encrypt (sizeof chg,	139	push_back (e);
113	(unsigned char )&chg, (unsigned char )&e->encr,
114	key, RSA_PKCS1_OAEP_PADDING))
115	fatal ("RSA_public_encrypt error");
116
117	return &e->encr;
118	}
119
120	const rsachallenge private_decrypt (RSA key, const rsaencrdata &encr)
121	{
122	for (iterator i = begin (); i != end (); ++i)
123	if (i->key == key && !memcmp (&encr, &i->encr, sizeof encr))
124	return &i->chg;
125		140
126	if (cleaner.at < NOW)	141	if (cleaner.at < NOW)
127	cleaner.start (NOW + CHALLENGE_TTL);	142	cleaner.start (NOW + RSA_TTL);
128
129	resize (size () + 1);
130	rsa_entry e = &(rbegin ());
131
132	e->key = key;
133	memcpy (&e->encr, &encr, sizeof encr);
134
135	if (0 > RSA_private_decrypt (sizeof encr,
136	(unsigned char )&encr, (unsigned char )&e->chg,
137	key, RSA_PKCS1_OAEP_PADDING))
138	{
139	pop_back ();
140	return 0;
141	}
142
143	return &e->chg;
144	}	143	}
145		144
146	rsa_cache ()	145	rsa_cache ()
147	: cleaner (this, &rsa_cache::cleaner_cb)	146	: cleaner (this, &rsa_cache::cleaner_cb)
148	{ }	147	{ }
…		…
153	{	152	{
154	if (empty ())	153	if (empty ())
155	ts = TSTAMP_CANCEL;	154	ts = TSTAMP_CANCEL;
156	else	155	else
157	{	156	{
158	ts = NOW + 3;	157	ts = NOW + RSA_TTL;
		158
159	for (iterator i = begin (); i != end (); )	159	for (iterator i = begin (); i != end (); )
160	{
161	if (i->expire >= NOW)	160	if (i->expire <= NOW)
162	i = erase (i);	161	i = erase (i);
163	else	162	else
164	++i;	163	++i;
165	}
166	}	164	}
167	}	165	}
168		166
169	// run a script. yes, it's a template function. yes, c++	167	typedef callback<const char *, int> run_script_cb;
170	// is not a functional language. yes, this suxx.	168
171	template<class owner>	169	// run a shell script (or actually an external program).
172	static void	170	static void
173	run_script (owner obj, const char (owner::*setup)(), bool wait)	171	run_script (const run_script_cb &cb, bool wait)
174	{	172	{
175	int pid;	173	int pid;
176		174
177	if ((pid = fork ()) == 0)	175	if ((pid = fork ()) == 0)
178	{	176	{
179	char *filename;	177	char *filename;
180	asprintf (&filename, "%s/%s", confbase, (obj->*setup) ());	178	asprintf (&filename, "%s/%s", confbase, cb(0));
181	execl (filename, filename, (char *) 0);	179	execl (filename, filename, (char *) 0);
182	exit (255);	180	exit (255);
183	}	181	}
184	else if (pid > 0)	182	else if (pid > 0)
185	{	183	{
…		…
187	{	185	{
188	waitpid (pid, 0, 0);	186	waitpid (pid, 0, 0);
189	/* TODO: check status */	187	/* TODO: check status */
190	}	188	}
191	}	189	}
192	}
193
194	// xor the socket address into the challenge to ensure different challenges
195	// per host. we could rely on the OAEP padding, but this doesn't hurt.
196	void
197	xor_sa (rsachallenge &k, SOCKADDR *sa)
198	{
199	((u32 *) k)[(CHG_CIPHER_KEY + 0) / 4] ^= sa->sin_addr.s_addr;
200	((u16 *) k)[(CHG_CIPHER_KEY + 4) / 2] ^= sa->sin_port;
201	((u32 *) k)[(CHG_HMAC_KEY + 0) / 4] ^= sa->sin_addr.s_addr;
202	((u16 *) k)[(CHG_HMAC_KEY + 4) / 2] ^= sa->sin_port;
203	}
204
205	struct crypto_ctx
206	{
207	EVP_CIPHER_CTX cctx;
208	HMAC_CTX hctx;
209
210	crypto_ctx (const rsachallenge &challenge, int enc);
211	~crypto_ctx ();
212	};
213
214	crypto_ctx::crypto_ctx (const rsachallenge &challenge, int enc)
215	{
216	EVP_CIPHER_CTX_init (&cctx);
217	EVP_CipherInit_ex (&cctx, CIPHER, 0, &challenge[CHG_CIPHER_KEY], 0, enc);
218	HMAC_CTX_init (&hctx);
219	HMAC_Init_ex (&hctx, &challenge[CHG_HMAC_KEY], HMAC_KEYLEN, DIGEST, 0);
220	}
221
222	crypto_ctx::~crypto_ctx ()
223	{
224	EVP_CIPHER_CTX_cleanup (&cctx);
225	HMAC_CTX_cleanup (&hctx);
226	}	190	}
227		191
228	//////////////////////////////////////////////////////////////////////////////	192	//////////////////////////////////////////////////////////////////////////////
229		193
230	void pkt_queue::put (tap_packet *p)	194	void pkt_queue::put (tap_packet *p)
…		…
326	bool send = ri.diff / ri.pcnt > CUTOFF;	290	bool send = ri.diff / ri.pcnt > CUTOFF;
327		291
328	if (send)	292	if (send)
329	ri.pcnt++;	293	ri.pcnt++;
330		294
331	//printf ("RATE %d %f,%f = %f > %f\n", !!send, ri.pcnt, ri.diff, ri.diff / ri.pcnt, CUTOFF);
332
333	push_front (ri);	295	push_front (ri);
334		296
335	return send;	297	return send;
336	}	298	}
337	}	299	}
…		…
345	}	307	}
346		308
347	static unsigned char hmac_digest[EVP_MAX_MD_SIZE];	309	static unsigned char hmac_digest[EVP_MAX_MD_SIZE];
348		310
349	struct hmac_packet:net_packet	311	struct hmac_packet:net_packet
		312	{
		313	u8 hmac[HMACLENGTH]; // each and every packet has a hmac field, but that is not (yet) checked everywhere
		314
		315	void hmac_set (crypto_ctx * ctx);
		316	bool hmac_chk (crypto_ctx * ctx);
		317
		318	private:
		319	void hmac_gen (crypto_ctx * ctx)
350	{	320	{
351	u8 hmac[HMACLENGTH]; // each and every packet has a hmac field, but that is not (yet) checked everywhere
352
353	void hmac_set (crypto_ctx * ctx);
354	bool hmac_chk (crypto_ctx * ctx);
355
356	private:
357	void hmac_gen (crypto_ctx * ctx)
358	{
359	unsigned int xlen;	321	unsigned int xlen;
360	HMAC_CTX *hctx = &ctx->hctx;	322	HMAC_CTX *hctx = &ctx->hctx;
361		323
362	HMAC_Init_ex (hctx, 0, 0, 0, 0);	324	HMAC_Init_ex (hctx, 0, 0, 0, 0);
363	HMAC_Update (hctx, ((unsigned char *) this) + sizeof (hmac_packet),	325	HMAC_Update (hctx, ((unsigned char *) this) + sizeof (hmac_packet),
364	len - sizeof (hmac_packet));	326	len - sizeof (hmac_packet));
365	HMAC_Final (hctx, (unsigned char *) &hmac_digest, &xlen);	327	HMAC_Final (hctx, (unsigned char *) &hmac_digest, &xlen);
366	}
367	};	328	}
		329	};
368		330
369	void	331	void
370	hmac_packet::hmac_set (crypto_ctx * ctx)	332	hmac_packet::hmac_set (crypto_ctx * ctx)
371	{	333	{
372	hmac_gen (ctx);	334	hmac_gen (ctx);
…		…
388	{	350	{
389	PT_RESET = 0,	351	PT_RESET = 0,
390	PT_DATA_UNCOMPRESSED,	352	PT_DATA_UNCOMPRESSED,
391	PT_DATA_COMPRESSED,	353	PT_DATA_COMPRESSED,
392	PT_PING, PT_PONG, // wasting namespace space? ;)	354	PT_PING, PT_PONG, // wasting namespace space? ;)
393	PT_AUTH, // authentification	355	PT_AUTH_REQ, // authentification request
		356	PT_AUTH_RES, // authentification response
394	PT_CONNECT_REQ, // want other host to contact me	357	PT_CONNECT_REQ, // want other host to contact me
395	PT_CONNECT_INFO, // request connection to some node	358	PT_CONNECT_INFO, // request connection to some node
396	PT_REKEY, // rekeying (not yet implemented)
397	PT_MAX	359	PT_MAX
398	};	360	};
399		361
400	u8 type;	362	u8 type;
401	u8 srcdst, src1, dst1;	363	u8 srcdst, src1, dst1;
…		…
539		501
540	#if ENABLE_COMPRESSION	502	#if ENABLE_COMPRESSION
541	if (type == PT_DATA_COMPRESSED)	503	if (type == PT_DATA_COMPRESSED)
542	{	504	{
543	u32 cl = (d[DATAHDR] << 8) \| d[DATAHDR + 1];	505	u32 cl = (d[DATAHDR] << 8) \| d[DATAHDR + 1];
		506
544	p->len = lzf_decompress (d + DATAHDR + 2, cl, &(*p)[6 + 6], MAX_MTU) + 6 + 6;	507	p->len = lzf_decompress (d + DATAHDR + 2, cl < MAX_MTU ? cl : 0,
		508	&(*p)[6 + 6], MAX_MTU)
		509	+ 6 + 6;
545	}	510	}
546	else	511	else
547	p->len = outl + (6 + 6 - DATAHDR);	512	p->len = outl + (6 + 6 - DATAHDR);
548	#endif	513	#endif
549		514
550	return p;	515	return p;
551	}	516	}
552		517
553	struct ping_packet : vpn_packet	518	struct ping_packet : vpn_packet
		519	{
		520	void setup (int dst, ptype type)
554	{	521	{
555	void setup (int dst, ptype type)
556	{
557	set_hdr (type, dst);	522	set_hdr (type, dst);
558	len = sizeof (*this) - sizeof (net_packet);	523	len = sizeof (*this) - sizeof (net_packet);
559	}
560	};	524	}
		525	};
561		526
562	struct config_packet : vpn_packet	527	struct config_packet : vpn_packet
		528	{
		529	// actually, hmaclen cannot be checked because the hmac
		530	// field comes before this data, so peers with other
		531	// hmacs simply will not work.
		532	u8 prot_major, prot_minor, randsize, hmaclen;
		533	u8 flags, challengelen, pad2, pad3;
		534	u32 cipher_nid, digest_nid, hmac_nid;
		535
		536	const u8 curflags () const
563	{	537	{
564	// actually, hmaclen cannot be checked because the hmac
565	// field comes before this data, so peers with other
566	// hmacs simply will not work.
567	u8 prot_major, prot_minor, randsize, hmaclen;
568	u8 flags, challengelen, pad2, pad3;
569	u32 cipher_nid;
570	u32 digest_nid;
571
572	const u8 curflags () const
573	{
574	return 0x80	538	return 0x80
575	\| (ENABLE_COMPRESSION ? 0x01 : 0x00);	539	\| (ENABLE_COMPRESSION ? 0x01 : 0x00);
576	}	540	}
577		541
578	void setup (ptype type, int dst)	542	void setup (ptype type, int dst)
579	{
580	prot_major = PROTOCOL_MAJOR;
581	prot_minor = PROTOCOL_MINOR;
582	randsize = RAND_SIZE;
583	hmaclen = HMACLENGTH;
584	flags = curflags ();
585	challengelen = sizeof (rsachallenge);
586
587	cipher_nid = htonl (EVP_CIPHER_nid (CIPHER));
588	digest_nid = htonl (EVP_MD_type (DIGEST));
589
590	len = sizeof (*this) - sizeof (net_packet);
591	set_hdr (type, dst);
592	}
593
594	bool chk_config ()
595	{
596	return prot_major == PROTOCOL_MAJOR
597	&& randsize == RAND_SIZE
598	&& hmaclen == HMACLENGTH
599	&& flags == curflags ()
600	&& challengelen == sizeof (rsachallenge)
601	&& cipher_nid == htonl (EVP_CIPHER_nid (CIPHER))
602	&& digest_nid == htonl (EVP_MD_type (DIGEST));
603	}
604	};
605
606	struct auth_packet : config_packet
607	{	543	{
608	char magic[8];	544	prot_major = PROTOCOL_MAJOR;
609	u8 subtype;	545	prot_minor = PROTOCOL_MINOR;
610	u8 pad1, pad2;	546	randsize = RAND_SIZE;
611	rsaencrdata challenge;	547	hmaclen = HMACLENGTH;
		548	flags = curflags ();
		549	challengelen = sizeof (rsachallenge);
612		550
613	auth_packet (int dst, auth_subtype stype)	551	cipher_nid = htonl (EVP_CIPHER_nid (CIPHER));
614	{	552	digest_nid = htonl (EVP_MD_type (RSA_HASH));
615	config_packet::setup (PT_AUTH, dst);	553	hmac_nid = htonl (EVP_MD_type (DIGEST));
616	subtype = stype;	554
617	len = sizeof (*this) - sizeof (net_packet);	555	len = sizeof (*this) - sizeof (net_packet);
		556	set_hdr (type, dst);
		557	}
		558
		559	bool chk_config ()
		560	{
		561	return prot_major == PROTOCOL_MAJOR
		562	&& randsize == RAND_SIZE
		563	&& hmaclen == HMACLENGTH
		564	&& flags == curflags ()
		565	&& challengelen == sizeof (rsachallenge)
		566	&& cipher_nid == htonl (EVP_CIPHER_nid (CIPHER))
		567	&& digest_nid == htonl (EVP_MD_type (RSA_HASH))
		568	&& hmac_nid == htonl (EVP_MD_type (DIGEST));
		569	}
		570	};
		571
		572	struct auth_req_packet : config_packet
		573	{
		574	char magic[8];
		575	u8 initiate; // false if this is just an automatic reply
		576	u8 pad1, pad2, pad3;
		577	rsaid id;
		578	rsaencrdata encr;
		579
		580	auth_req_packet (int dst, bool initiate_)
		581	{
		582	config_packet::setup (PT_AUTH_REQ, dst);
		583	initiate = !!initiate_;
618	strncpy (magic, MAGIC, 8);	584	strncpy (magic, MAGIC, 8);
619	}	585	len = sizeof (*this) - sizeof (net_packet);
620	};	586	}
		587	};
		588
		589	struct auth_res_packet : config_packet
		590	{
		591	rsaid id;
		592	u8 pad1, pad2, pad3;
		593	u8 response_len; // encrypted length
		594	rsaresponse response;
		595
		596	auth_res_packet (int dst)
		597	{
		598	config_packet::setup (PT_AUTH_RES, dst);
		599	len = sizeof (*this) - sizeof (net_packet);
		600	}
		601	};
621		602
622	struct connect_req_packet : vpn_packet	603	struct connect_req_packet : vpn_packet
		604	{
		605	u8 id;
		606	u8 pad1, pad2, pad3;
		607
		608	connect_req_packet (int dst, int id_)
623	{	609	{
624	u8 id;	610	id = id_;
625	u8 pad1, pad2, pad3;
626
627	connect_req_packet (int dst, int id)
628	{
629	this->id = id;
630	set_hdr (PT_CONNECT_REQ, dst);	611	set_hdr (PT_CONNECT_REQ, dst);
631	len = sizeof (*this) - sizeof (net_packet);	612	len = sizeof (*this) - sizeof (net_packet);
632	}
633	};	613	}
		614	};
634		615
635	struct connect_info_packet : vpn_packet	616	struct connect_info_packet : vpn_packet
		617	{
		618	u8 id;
		619	u8 pad1, pad2, pad3;
		620	sockinfo si;
		621
		622	connect_info_packet (int dst, int id_, sockinfo &si_)
636	{	623	{
637	u8 id;	624	id = id_;
638	u8 pad1, pad2, pad3;	625	si = si_;
639	sockinfo si;
640
641	connect_info_packet (int dst, int id, sockinfo &si)
642	{
643	this->id = id;
644	this->si = si;
645	set_hdr (PT_CONNECT_INFO, dst);	626	set_hdr (PT_CONNECT_INFO, dst);
646	len = sizeof (*this) - sizeof (net_packet);	627	len = sizeof (*this) - sizeof (net_packet);
647	}
648	};	628	}
		629	};
649		630
650	/////////////////////////////////////////////////////////////////////////////	631	/////////////////////////////////////////////////////////////////////////////
651		632
652	void	633	void
653	fill_sa (SOCKADDR sa, conf_node conf)	634	fill_sa (SOCKADDR sa, conf_node conf)
…		…
700		681
701	delete pkt;	682	delete pkt;
702	}	683	}
703	}	684	}
704		685
705	static rsachallenge *
706	gen_challenge (u32 seqrand, SOCKADDR *sa)
707	{
708	static rsachallenge k;
709
710	memcpy (&k, &challenge_bytes (), sizeof (k));
711	(u32 )&k[CHG_SEQNO] ^= seqrand;
712	xor_sa (k, sa);
713
714	return &k;
715	}
716
717	void	686	void
718	connection::send_auth (auth_subtype subtype, SOCKADDR sa, const rsachallenge k)	687	connection::send_auth_request (SOCKADDR *sa, bool initiate)
719	{	688	{
720	if (subtype == AUTH_REPLY \|\| auth_rate_limiter.can (sa))	689	if (!initiate \|\| auth_rate_limiter.can (sa))
721	{	690	{
722	if (!k)
723	k = gen_challenge (seqrand, sa);
724
725	auth_packet *pkt = new auth_packet (conf->id, subtype);	691	auth_req_packet *pkt = new auth_req_packet (conf->id, initiate);
726		692
727	memcpy (pkt->challenge, rsa_cache.public_encrypt (conf->rsa_key, *k), sizeof (rsaencrdata));	693	rsachallenge chg;
728		694
		695	rsa_cache.gen (pkt->id, chg);
		696
		697	if (0 > RSA_public_encrypt (sizeof chg,
		698	(unsigned char )&chg, (unsigned char )&pkt->encr,
		699	conf->rsa_key, RSA_PKCS1_OAEP_PADDING))
		700	fatal ("RSA_public_encrypt error");
		701
729	slog (L_TRACE, ">>%d PT_AUTH(%d) [%s]", conf->id, subtype, (const char *)sockinfo (sa));	702	slog (L_TRACE, ">>%d PT_AUTH_REQ [%s]", conf->id, (const char *)sockinfo (sa));
730		703
731	vpn->send_vpn_packet (pkt, sa, IPTOS_RELIABILITY);	704	vpn->send_vpn_packet (pkt, sa, IPTOS_RELIABILITY); // rsa is very very costly
732		705
733	delete pkt;	706	delete pkt;
734	}	707	}
735	}	708	}
736		709
737	void	710	void
		711	connection::send_auth_response (SOCKADDR *sa, const rsaid &id, const rsachallenge &chg)
		712	{
		713	auth_res_packet *pkt = new auth_res_packet (conf->id);
		714
		715	pkt->id = id;
		716
		717	rsa_hash (id, chg, pkt->response);
		718
		719	pkt->hmac_set (octx);
		720
		721	slog (L_TRACE, ">>%d PT_AUTH_RES [%s]", conf->id, (const char *)sockinfo (sa));
		722
		723	vpn->send_vpn_packet (pkt, sa, IPTOS_RELIABILITY); // rsa is very very costly
		724
		725	delete pkt;
		726	}
		727
		728	void
738	connection::establish_connection_cb (tstamp &ts)	729	connection::establish_connection_cb (tstamp &ts)
739	{	730	{
740	if (ictx \|\| conf == THISNODE \|\| connectmode == conf_node::C_NEVER)	731	if (ictx \|\| conf == THISNODE
		732	\|\| connectmode == conf_node::C_NEVER
		733	\|\| connectmode == conf_node::C_DISABLED)
741	ts = TSTAMP_CANCEL;	734	ts = TSTAMP_CANCEL;
742	else if (ts <= NOW)	735	else if (ts <= NOW)
743	{	736	{
744	double retry_int = double (retry_cnt & 3 ? (retry_cnt & 3) : 1 << (retry_cnt >> 2)) * 0.25;	737	double retry_int = double (retry_cnt & 3 ? (retry_cnt & 3) : 1 << (retry_cnt >> 2)) * 0.6;
745		738
746	if (retry_int < 3600 * 8)	739	if (retry_int < 3600 * 8)
747	retry_cnt++;	740	retry_cnt++;
748		741
749	ts = NOW + retry_int;	742	ts = NOW + retry_int;
…		…
751	if (conf->hostname)	744	if (conf->hostname)
752	{	745	{
753	reset_dstaddr ();	746	reset_dstaddr ();
754	if (sa.sin_addr.s_addr)	747	if (sa.sin_addr.s_addr)
755	if (retry_cnt < 4)	748	if (retry_cnt < 4)
756	send_auth (AUTH_INIT, &sa);	749	send_auth_request (&sa, true);
757	else if (auth_rate_limiter.can (&sa))	750	else if (auth_rate_limiter.can (&sa))
758	send_ping (&sa, 0);	751	send_ping (&sa, 0);
759	}	752	}
760	else	753	else
761	vpn->connect_request (conf->id);	754	vpn->connect_request (conf->id);
…		…
765	void	758	void
766	connection::reset_connection ()	759	connection::reset_connection ()
767	{	760	{
768	if (ictx && octx)	761	if (ictx && octx)
769	{	762	{
770	slog (L_INFO, _("connection to %d (%s) lost"), conf->id, conf->nodename);	763	slog (L_INFO, _("%s(%s): connection lost"),
		764	conf->nodename, (const char *)sockinfo (sa));
771		765
772	if (::conf.script_node_down)	766	if (::conf.script_node_down)
773	run_script (this, &connection::script_node_down, false);	767	run_script (run_script_cb (this, &connection::script_node_down), false);
774	}	768	}
775		769
776	delete ictx; ictx = 0;	770	delete ictx; ictx = 0;
777	delete octx; octx = 0;	771	delete octx; octx = 0;
778
779	RAND_bytes ((unsigned char *)&seqrand, sizeof (u32));
780		772
781	sa.sin_port = 0;	773	sa.sin_port = 0;
782	sa.sin_addr.s_addr = 0;	774	sa.sin_addr.s_addr = 0;
783		775
784	last_activity = 0;	776	last_activity = 0;
…		…
871	case vpn_packet::PT_RESET:	863	case vpn_packet::PT_RESET:
872	{	864	{
873	reset_connection ();	865	reset_connection ();
874		866
875	config_packet p = (config_packet ) pkt;	867	config_packet p = (config_packet ) pkt;
		868
876	if (!p->chk_config ())	869	if (!p->chk_config ())
877	{	870	{
878	slog (L_WARN, _("protocol mismatch, disabling node '%s'"), conf->nodename);	871	slog (L_WARN, _("%s(%s): protocol mismatch, disabling node"),
		872	conf->nodename, (const char *)sockinfo (ssa));
879	connectmode = conf_node::C_DISABLED;	873	connectmode = conf_node::C_DISABLED;
880	}	874	}
881	else if (connectmode == conf_node::C_ALWAYS)	875	else if (connectmode == conf_node::C_ALWAYS)
882	establish_connection ();	876	establish_connection ();
883	}	877	}
884	break;	878	break;
885		879
886	case vpn_packet::PT_AUTH:	880	case vpn_packet::PT_AUTH_REQ:
		881	if (auth_rate_limiter.can (ssa))
		882	{
		883	auth_req_packet p = (auth_req_packet ) pkt;
		884
		885	slog (L_TRACE, "<<%d PT_AUTH_REQ(%d)", conf->id, p->initiate);
		886
		887	if (p->chk_config () && !strncmp (p->magic, MAGIC, 8))
		888	{
		889	if (p->prot_minor != PROTOCOL_MINOR)
		890	slog (L_INFO, _("%s(%s): protocol minor version mismatch: ours is %d, %s's is %d."),
		891	conf->nodename, (const char *)sockinfo (ssa),
		892	PROTOCOL_MINOR, conf->nodename, p->prot_minor);
		893
		894	if (p->initiate)
		895	send_auth_request (ssa, false);
		896
		897	rsachallenge k;
		898
		899	if (0 > RSA_private_decrypt (sizeof (p->encr),
		900	(unsigned char )&p->encr, (unsigned char )&k,
		901	::conf.rsa_key, RSA_PKCS1_OAEP_PADDING))
		902	slog (L_ERR, _("%s(%s): challenge illegal or corrupted"),
		903	conf->nodename, (const char *)sockinfo (ssa));
		904	else
		905	{
		906	retry_cnt = 0;
		907	establish_connection.set (NOW + 8); //? ;)
		908	keepalive.reset ();
		909	rekey.reset ();
		910
		911	delete ictx;
		912	ictx = 0;
		913
		914	delete octx;
		915
		916	octx = new crypto_ctx (k, 1);
		917	oseqno = ntohl ((u32 )&k[CHG_SEQNO]) & 0x7fffffff;
		918
		919	send_auth_response (ssa, p->id, k);
		920
		921	break;
		922	}
		923	}
		924
		925	send_reset (ssa);
		926	}
		927
		928	break;
		929
		930	case vpn_packet::PT_AUTH_RES:
887	{	931	{
888	auth_packet p = (auth_packet ) pkt;	932	auth_res_packet p = (auth_res_packet ) pkt;
889		933
890	slog (L_TRACE, "<<%d PT_AUTH(%d)", conf->id, p->subtype);	934	slog (L_TRACE, "<<%d PT_AUTH_RES", conf->id);
891		935
892	if (p->chk_config ()	936	if (p->chk_config ())
893	&& !strncmp (p->magic, MAGIC, 8))
894	{	937	{
895	if (p->prot_minor != PROTOCOL_MINOR)	938	if (p->prot_minor != PROTOCOL_MINOR)
896	slog (L_INFO, _("protocol minor version mismatch: ours is %d, %s's is %d."),	939	slog (L_INFO, _("%s(%s): protocol minor version mismatch: ours is %d, %s's is %d."),
		940	conf->nodename, (const char *)sockinfo (ssa),
897	PROTOCOL_MINOR, conf->nodename, p->prot_minor);	941	PROTOCOL_MINOR, conf->nodename, p->prot_minor);
898		942
899	if (p->subtype == AUTH_INIT)	943	rsachallenge chg;
900	send_auth (AUTH_INITREPLY, ssa);
901		944
902	const rsachallenge *k = rsa_cache.private_decrypt (::conf.rsa_key, p->challenge);	945	if (!rsa_cache.find (p->id, chg))
903		946	slog (L_ERR, _("%s(%s): unrequested auth response"),
904	if (!k)	947	conf->nodename, (const char *)sockinfo (ssa));
		948	else
905	{	949	{
906	slog (L_ERR, _("challenge from %s (%s) illegal or corrupted"),	950	crypto_ctx *cctx = new crypto_ctx (chg, 0);
		951
		952	if (!p->hmac_chk (cctx))
		953	slog (L_ERR, _("%s(%s): hmac authentication error on auth response, received invalid packet\n"
		954	"could be an attack, or just corruption or an synchronization error"),
907	conf->nodename, (const char *)sockinfo (ssa));	955	conf->nodename, (const char *)sockinfo (ssa));
908	send_reset (ssa);
909	break;	956	else
910	}
911
912	retry_cnt = 0;
913	establish_connection.set (NOW + 8); //? ;)
914	keepalive.reset ();
915	rekey.reset ();
916
917	switch (p->subtype)
918	{
919	case AUTH_INIT:
920	case AUTH_INITREPLY:
921	delete ictx;
922	ictx = 0;
923
924	delete octx;
925
926	octx = new crypto_ctx (*k, 1);
927	oseqno = ntohl ((u32 )&k[CHG_SEQNO]) & 0x7fffffff;
928
929	send_auth (AUTH_REPLY, ssa, k);
930	break;
931
932	case AUTH_REPLY:
933
934	if (!memcmp ((u8 )gen_challenge (seqrand, ssa), (u8 )k, sizeof (rsachallenge)))
935	{	957	{
936	delete ictx;
937
938	ictx = new crypto_ctx (*k, 0);
939	iseqno.reset (ntohl ((u32 )&k[CHG_SEQNO]) & 0x7fffffff); // at least 2**31 sequence numbers are valid
940
941	sa = *ssa;	958	rsaresponse h;
942		959
943	rekey.set (NOW + ::conf.rekey);	960	rsa_hash (p->id, chg, h);
944	keepalive.set (NOW + ::conf.keepalive);
945		961
946	// send queued packets	962	if (!memcmp ((u8 )&h, (u8 )p->response, sizeof h))
947	while (tap_packet *p = queue.get ())
948	{	963	{
		964	prot_minor = p->prot_minor;
		965
		966	delete ictx; ictx = cctx;
		967
		968	iseqno.reset (ntohl ((u32 )&chg[CHG_SEQNO]) & 0x7fffffff); // at least 2**31 sequence numbers are valid
		969
		970	sa = *ssa;
		971
		972	rekey.set (NOW + ::conf.rekey);
		973	keepalive.set (NOW + ::conf.keepalive);
		974
		975	// send queued packets
		976	while (tap_packet *p = queue.get ())
		977	{
949	send_data_packet (p);	978	send_data_packet (p);
950	delete p;	979	delete p;
		980	}
		981
		982	connectmode = conf->connectmode;
		983
		984	slog (L_INFO, _("%s(%s): connection established, protocol version %d:%d"),
		985	conf->nodename, (const char *)sockinfo (ssa),
		986	p->prot_major, p->prot_minor);
		987
		988	if (::conf.script_node_up)
		989	run_script (run_script_cb (this, &connection::script_node_up), false);
		990
		991	break;
951	}	992	}
952		993	else
953	connectmode = conf->connectmode;	994	slog (L_ERR, _("%s(%s): sent and received challenge do not match"),
954
955	slog (L_INFO, _("connection to %d (%s %s) established"),
956	conf->id, conf->nodename, (const char *)sockinfo (ssa));	995	conf->nodename, (const char *)sockinfo (ssa));
957
958	if (::conf.script_node_up)
959	run_script (this, &connection::script_node_up, false);
960	}	996	}
		997
961	else	998	delete cctx;
962	slog (L_ERR, _("sent and received challenge do not match with (%s %s))"),
963	conf->nodename, (const char *)sockinfo (ssa));
964
965	break;
966	default:
967	slog (L_ERR, _("authentification illegal subtype error (%s %s)"),
968	conf->nodename, (const char *)sockinfo (ssa));
969	break;
970	}	999	}
971	}	1000	}
972	else
973	send_reset (ssa);
974
975	break;
976	}	1001	}
		1002
		1003	send_reset (ssa);
		1004	break;
977		1005
978	case vpn_packet::PT_DATA_COMPRESSED:	1006	case vpn_packet::PT_DATA_COMPRESSED:
979	#if !ENABLE_COMPRESSION	1007	#if !ENABLE_COMPRESSION
980	send_reset (ssa);	1008	send_reset (ssa);
981	break;	1009	break;
982	#endif	1010	#endif
		1011
983	case vpn_packet::PT_DATA_UNCOMPRESSED:	1012	case vpn_packet::PT_DATA_UNCOMPRESSED:
984		1013
985	if (ictx && octx)	1014	if (ictx && octx)
986	{	1015	{
987	vpndata_packet p = (vpndata_packet )pkt;	1016	vpndata_packet p = (vpndata_packet )pkt;
988		1017
989	if (*ssa == sa)	1018	if (*ssa == sa)
990	{	1019	{
991	if (!p->hmac_chk (ictx))	1020	if (!p->hmac_chk (ictx))
992	slog (L_ERR, _("hmac authentication error, received invalid packet\n"	1021	slog (L_ERR, _("%s(%s): hmac authentication error, received invalid packet\n"
993	"could be an attack, or just corruption or an synchronization error"));	1022	"could be an attack, or just corruption or an synchronization error"),
		1023	conf->nodename, (const char *)sockinfo (ssa));
994	else	1024	else
995	{	1025	{
996	u32 seqno;	1026	u32 seqno;
997	tap_packet *d = p->unpack (this, seqno);	1027	tap_packet *d = p->unpack (this, seqno);
998		1028
…		…
1080	connection *c = vpn->conns[p->id - 1];	1110	connection *c = vpn->conns[p->id - 1];
1081		1111
1082	slog (L_TRACE, "<<%d PT_CONNECT_INFO(%d,%s) (%d)",	1112	slog (L_TRACE, "<<%d PT_CONNECT_INFO(%d,%s) (%d)",
1083	conf->id, p->id, (const char *)p->si, !c->ictx && !c->octx);	1113	conf->id, p->id, (const char *)p->si, !c->ictx && !c->octx);
1084		1114
1085	c->send_auth (AUTH_INIT, p->si.sa ());	1115	c->send_auth_request (p->si.sa (), true);
1086	}	1116	}
		1117
1087	break;	1118	break;
1088		1119
1089	default:	1120	default:
1090	send_reset (ssa);	1121	send_reset (ssa);
1091	break;	1122	break;
		1123
1092	}	1124	}
1093	}	1125	}
1094		1126
1095	void connection::keepalive_cb (tstamp &ts)	1127	void connection::keepalive_cb (tstamp &ts)
1096	{	1128	{
…		…
1123	delete p;	1155	delete p;
1124	}	1156	}
1125		1157
1126	void connection::script_node ()	1158	void connection::script_node ()
1127	{	1159	{
1128	vpn->script_if_up ();	1160	vpn->script_if_up (0);
1129		1161
1130	char *env;	1162	char *env;
1131	asprintf (&env, "DESTID=%d", conf->id);	1163	asprintf (&env, "DESTID=%d", conf->id);
1132	putenv (env);	1164	putenv (env);
1133	asprintf (&env, "DESTNODE=%s", conf->nodename);	1165	asprintf (&env, "DESTNODE=%s", conf->nodename);
…		…
1136	putenv (env);	1168	putenv (env);
1137	asprintf (&env, "DESTPORT=%d", ntohs (sa.sin_port));	1169	asprintf (&env, "DESTPORT=%d", ntohs (sa.sin_port));
1138	putenv (env);	1170	putenv (env);
1139	}	1171	}
1140		1172
1141	const char *connection::script_node_up ()	1173	const char *connection::script_node_up (int)
1142	{	1174	{
1143	script_node ();	1175	script_node ();
1144		1176
1145	putenv ("STATE=up");	1177	putenv ("STATE=up");
1146		1178
1147	return ::conf.script_node_up ? ::conf.script_node_up : "node-up";	1179	return ::conf.script_node_up ? ::conf.script_node_up : "node-up";
1148	}	1180	}
1149		1181
1150	const char *connection::script_node_down ()	1182	const char *connection::script_node_down (int)
1151	{	1183	{
1152	script_node ();	1184	script_node ();
1153		1185
1154	putenv ("STATE=down");	1186	putenv ("STATE=down");
1155		1187
…		…
1174	shutdown ();	1206	shutdown ();
1175	}	1207	}
1176		1208
1177	/////////////////////////////////////////////////////////////////////////////	1209	/////////////////////////////////////////////////////////////////////////////
1178		1210
1179	const char *vpn::script_if_up ()	1211	const char *vpn::script_if_up (int)
1180	{	1212	{
1181	// the tunnel device mtu should be the physical mtu - overhead	1213	// the tunnel device mtu should be the physical mtu - overhead
1182	// the tricky part is rounding to the cipher key blocksize	1214	// the tricky part is rounding to the cipher key blocksize
1183	int mtu = conf.mtu - ETH_OVERHEAD - VPE_OVERHEAD - UDP_OVERHEAD;	1215	int mtu = conf.mtu - ETH_OVERHEAD - VPE_OVERHEAD - MAX_OVERHEAD;
1184	mtu += ETH_OVERHEAD - 6 - 6; // now we have the data portion	1216	mtu += ETH_OVERHEAD - 6 - 6; // now we have the data portion
1185	mtu -= mtu % EVP_CIPHER_block_size (CIPHER); // round	1217	mtu -= mtu % EVP_CIPHER_block_size (CIPHER); // round
1186	mtu -= ETH_OVERHEAD - 6 - 6; // and get interface mtu again	1218	mtu -= ETH_OVERHEAD - 6 - 6; // and get interface mtu again
1187		1219
1188	char *env;	1220	char *env;
…		…
1242	{	1274	{
1243	slog (L_ERR, _("cannot create network interface '%s'"), conf.ifname);	1275	slog (L_ERR, _("cannot create network interface '%s'"), conf.ifname);
1244	exit (1);	1276	exit (1);
1245	}	1277	}
1246		1278
1247	run_script (this, &vpn::script_if_up, true);	1279	run_script (run_script_cb (this, &vpn::script_if_up), true);
1248		1280
1249	vpn_ev_watcher.start (tap->fd, POLLIN);	1281	vpn_ev_watcher.start (tap->fd, POLLIN);
1250		1282
1251	reconnect_all ();	1283	reconnect_all ();
1252		1284
…		…
1466	}	1498	}
1467		1499
1468	ts = TSTAMP_CANCEL;	1500	ts = TSTAMP_CANCEL;
1469	}	1501	}
1470		1502
1471	#include <sys/time.h>//D
1472	vpn::vpn (void)	1503	vpn::vpn (void)
1473	: udp_ev_watcher (this, &vpn::udp_ev)	1504	: udp_ev_watcher (this, &vpn::udp_ev)
1474	, vpn_ev_watcher (this, &vpn::vpn_ev)	1505	, vpn_ev_watcher (this, &vpn::vpn_ev)
1475	, event (this, &vpn::event_cb)	1506	, event (this, &vpn::event_cb)
1476	{	1507	{

Diff Legend

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

Comparing gvpe/src/protocol.C (file contents): Revision 1.16 by pcg, Tue Mar 25 18:11:58 2003 UTC vs. Revision 1.19 by pcg, Wed Mar 26 14:39:52 2003 UTC

Diff Legend

Comparing gvpe/src/protocol.C (file contents):
Revision 1.16 by pcg, Tue Mar 25 18:11:58 2003 UTC vs.
Revision 1.19 by pcg, Wed Mar 26 14:39:52 2003 UTC