Context Navigation

source: trunk/src/sh_tools.c@ 249

Last change on this file since 249 was 248, checked in by katerina, 15 years ago
Code to track down originating site for ticket #163.
File size: 42.2 KB

Rev	Line
[1]	1	/* SAMHAIN file system integrity testing */
	2	/* Copyright (C) 1999, 2000 Rainer Wichmann */
	3	/* */
	4	/* This program is free software; you can redistribute it */
	5	/* and/or modify */
	6	/* it under the terms of the GNU General Public License as */
	7	/* published by */
	8	/* the Free Software Foundation; either version 2 of the License, or */
	9	/* (at your option) any later version. */
	10	/* */
	11	/* This program is distributed in the hope that it will be useful, */
	12	/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
	13	/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
	14	/* GNU General Public License for more details. */
	15	/* */
	16	/* You should have received a copy of the GNU General Public License */
	17	/* along with this program; if not, write to the Free Software */
	18	/* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
	19
	20	#include "config_xor.h"
	21
	22
	23	#include <stdio.h>
	24	#include <stdlib.h>
	25	#include <string.h>
	26	#include <ctype.h>
	27
	28	/* Must be early on FreeBSD
	29	*/
	30	#include <sys/types.h>
	31
	32	#ifdef HAVE_MEMORY_H
	33	#include <memory.h>
	34	#endif
	35
	36	#ifdef HAVE_SYS_SELECT_H
	37	#include <sys/select.h>
	38	#endif
	39
	40	#ifdef HAVE_UNISTD_H
	41	#include <errno.h>
	42	#include <signal.h>
	43	#include <setjmp.h>
	44	#include <pwd.h>
	45	#include <grp.h>
	46	#include <sys/stat.h>
	47	#include <sys/resource.h>
	48	#include <fcntl.h>
	49	#include <sys/wait.h>
	50	#include <unistd.h>
	51	#endif
	52
	53	#include <sys/socket.h>
	54
	55	#ifdef HOST_IS_HPUX
	56	#define _XOPEN_SOURCE_EXTENDED
	57	#endif
	58	#include <netinet/in.h>
	59	#include <arpa/inet.h>
	60	#include <netdb.h>
	61
	62	#ifndef FD_SET
	63	#define NFDBITS 32
	64	#define FD_SET(n, p) ((p)->fds_bits[(n)/NFDBITS] \|= (1 << ((n) % NFDBITS)))
	65	#define FD_CLR(n, p) ((p)->fds_bits[(n)/NFDBITS] &= ~(1 << ((n) % NFDBITS)))
	66	#define FD_ISSET(n, p) ((p)->fds_bits[(n)/NFDBITS] & (1 << ((n) % NFDBITS)))
	67	#endif /* !FD_SET */
	68	#ifndef FD_SETSIZE
	69	#define FD_SETSIZE 32
	70	#endif
	71	#ifndef FD_ZERO
	72	#define FD_ZERO(p) memset((char )(p), '\0', sizeof((p)))
	73	#endif
	74
	75
	76	#if defined(HAVE_MLOCK) && !defined(HAVE_BROKEN_MLOCK)
	77	#include <sys/mman.h>
	78	#endif
	79
[11]	80	#define SH_REAL_SET
	81
[1]	82	#include "samhain.h"
	83	#include "sh_mem.h"
	84	#include "sh_error.h"
	85	#include "sh_tools.h"
	86	#include "sh_utils.h"
	87	#include "sh_tiger.h"
	88	#define SH_NEED_GETHOSTBYXXX
	89	#include "sh_static.h"
[137]	90	#include "sh_pthread.h"
[1]	91
	92	#undef FIL__
	93	#define FIL__ _("sh_tools.c")
	94
	95	#ifdef SH_ENCRYPT
	96	#include "rijndael-api-fst.h"
[132]	97	char * errorExplain (int err_num, char * buffer, size_t len)
[1]	98	{
[132]	99	char * p;
	100
[1]	101	if (err_num == BAD_KEY_DIR)
[132]	102	p = (_("Key direction is invalid"));
[1]	103	else if (err_num == BAD_KEY_MAT)
[132]	104	p = (_("Key material not of correct length"));
[1]	105	else if (err_num == BAD_KEY_INSTANCE)
[132]	106	p = (_("Key passed is not valid"));
[1]	107	else if (err_num == BAD_CIPHER_MODE)
[132]	108	p = (_("Params struct passed to cipherInit invalid"));
[1]	109	else if (err_num == BAD_CIPHER_STATE)
[132]	110	p = (_("Cipher in wrong state"));
[1]	111	else if (err_num == BAD_BLOCK_LENGTH)
[132]	112	p = (_("Bad block length"));
[1]	113	else if (err_num == BAD_CIPHER_INSTANCE)
[132]	114	p = (_("Bad cipher instance"));
[1]	115	else if (err_num == BAD_DATA)
[132]	116	p = (_("Data contents are invalid"));
[1]	117	else
[132]	118	p = (_("Unknown error"));
	119	sl_strlcpy (buffer, p, len);
	120	return buffer;
[1]	121	}
	122
	123	#endif
	124
[197]	125	/* --- check for an interface ---
	126	*/
	127	int sh_tools_iface_is_present(char *str)
	128	{
	129	struct sockaddr_in sin;
	130	int sd;
	131
	132	memset(&sin, '\0', sizeof(sin));
	133	sin.sin_family = AF_INET;
	134	if (inet_aton(str, &(sin.sin_addr)))
	135	{
	136	sin.sin_port = htons(2543);
	137
	138	if (-1 == (sd = socket(AF_INET, SOCK_STREAM, 0)))
	139	{
	140	return 0;
	141	}
	142
	143	if (-1 == bind(sd, (struct sockaddr *)&sin, sizeof(sin)))
	144	{
	145	int retval = 0;
	146
	147	/* bind() fails for access reasons, iface exists
	148	*/
	149	if (errno == EACCES \|\| errno == EADDRINUSE)
	150	retval = 1;
	151	close (sd);
	152	return retval;
	153	}
	154
	155	/* bind() succeeds, iface exists
	156	*/
	157	close(sd);
	158	return 1;
	159	}
	160	return 0;
	161	}
	162
[1]	163	/* --- recode all \blah escapes to '=XX' format, and also code all
	164	* remaining unprintable chars ---
	165	*/
[12]	166	#define SH_PUT_4(p, a, b, c) (p)[0] = (a); (p)[1] = (b); (p)[2] = (c);
	167
[1]	168	char * sh_tools_safe_name (const char * instr, int flag)
	169	{
[18]	170	unsigned char c, d;
[1]	171	const char * p;
	172	char tmp[4];
	173	char * outstr;
[34]	174	size_t len = 1;
[1]	175	int i = 0;
	176	unsigned char val_octal = '\0';
[18]	177	static char ctable[16] = { '0', '1', '2', '3', '4', '5', '6', '7',
	178	'8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
[1]	179
	180	SL_ENTER(_("sh_tools_safe_name"));
	181
	182	if (instr)
[34]	183	{
	184	len = strlen(instr);
	185	if (sl_ok_muls (3, len) && sl_ok_adds ((3*len), 4))
	186	{
	187	len = (3 * len) + 4;
	188	p = instr;
	189	}
	190	else
	191	{
	192	len = 1;
	193	p = NULL;
	194	}
	195	}
	196	else
	197	{
	198	p = NULL;
	199	}
[1]	200
	201	outstr = SH_ALLOC(len);
	202
	203	outstr[0] = '\0';
	204	tmp[3] = '\0';
	205
[11]	206	#if !defined(SH_USE_XML)
	207	(void) flag; /* fix compiler warning */
	208	#endif
	209
	210	if (!p)
	211	goto end;
	212
	213	while (*p)
[1]	214	{
	215	c = *p;
	216
	217	if (*p == '\n')
	218	{
	219	outstr[i] = ' '; ++i; ++p;
	220	continue;
	221	}
	222
	223	#ifdef SH_USE_XML
[11]	224	if (flag == 1)
	225	{
	226	if ((*p) == '"')
	227	{
[12]	228	SH_PUT_4(&outstr[i], '=', '2', '2');
	229	i+=3; ++p;
[11]	230	continue;
	231	}
	232	else if ((*p) == '&')
	233	{
[12]	234	SH_PUT_4(&outstr[i], '=', '2', '6');
	235	i+=3; ++p;
[11]	236	continue;
	237	}
	238	else if ((*p) == '<')
	239	{ /* left angle */
[12]	240	SH_PUT_4(&outstr[i], '=', '3', 'c');
	241	i+=3; ++p;
[11]	242	continue;
	243	}
	244	else if ((*p) == '>')
	245	{ /* right angle */
[12]	246	SH_PUT_4(&outstr[i], '=', '3', 'e');
	247	i+=3; ++p;
[11]	248	continue;
	249	}
[1]	250	}
	251	#endif
	252
[12]	253	if ( (p) != '\\' && (p) != '&' && (p) != '=' && (p) != '\'')
[1]	254	{
[11]	255	outstr[i] = *p; ++i;
	256	++p;
	257
[81]	258	if (c < 32 \|\| c > 126)
[1]	259	{
[11]	260	--i;
[18]	261	d = c % 16; c = c / 16;
	262	outstr[i] = '='; ++i;
	263	outstr[i] = ctable[c]; ++i;
	264	outstr[i] = ctable[d]; ++i;
[1]	265	}
[11]	266
[1]	267	continue;
	268	}
	269	else if ((*p) == '\'')
	270	{
[12]	271	SH_PUT_4(&outstr[i], '=', '2', '7');
	272	i+=3; ++p;
[1]	273	}
	274	else if (*p == '=')
	275	{
	276	if (p[1] != '"' && p[1] != '<')
	277	{
[12]	278	SH_PUT_4(&outstr[i], '=', '3', 'd');
	279	i+=3; ++p;
[1]	280	}
	281	else
	282	{ outstr[i] = *p; ++i; ++p; }
	283	}
	284	else if (*p == '\\')
	285	{
	286	++p;
	287	if (!p)
	288	break;
	289	if (!(*p))
	290	break;
	291
	292	c = *p;
	293
	294	switch (*p) {
	295	case '\\':
[12]	296	SH_PUT_4(&outstr[i], '=', '5', 'c');
	297	i+=3; ++p;
[1]	298	break;
	299	case 'n':
[12]	300	SH_PUT_4(&outstr[i], '=', '0', 'a');
[1]	301	i+=3; ++p;
	302	break;
	303	case 'b':
[12]	304	SH_PUT_4(&outstr[i], '=', '0', '8');
[1]	305	i+=3; ++p;
	306	break;
	307	case 'r':
[12]	308	SH_PUT_4(&outstr[i], '=', '0', 'd');
[1]	309	i+=3; ++p;
	310	break;
	311	case 't':
[12]	312	SH_PUT_4(&outstr[i], '=', '0', '9');
[1]	313	i+=3; ++p;
	314	break;
	315	case 'v':
[12]	316	SH_PUT_4(&outstr[i], '=', '0', 'b');
[1]	317	i+=3; ++p;
	318	break;
	319	case 'f':
[12]	320	SH_PUT_4(&outstr[i], '=', '0', 'c');
[1]	321	i+=3; ++p;
	322	break;
	323	case '\'':
[12]	324	SH_PUT_4(&outstr[i], '=', '2', '7');
[1]	325	i+=3; ++p;
	326	break;
[12]	327	case '"': /* also encode quoted '"' */
	328	SH_PUT_4(&outstr[i], '=', '2', '2');
[1]	329	i+=3; ++p;
	330	break;
	331	case ' ':
[12]	332	SH_PUT_4(&outstr[i], '=', '2', '0');
[1]	333	i+=3; ++p;
	334	break;
	335	default:
[18]	336	if (strlen(p) < 3) /* certainly not an octal number, skip */
[1]	337	{
	338	p += strlen(p);
	339	}
	340	else
	341	{
	342	tmp[0] = p[0]; tmp[1] = p[1]; tmp[2] = p[2];
	343	val_octal = (unsigned char) strtoul(tmp, (char **)NULL, 8);
	344	if (val_octal != '\0') {
	345	c = val_octal;
[18]	346	d = c % 16; c = c / 16;
	347	outstr[i] = '='; ++i;
	348	outstr[i] = ctable[c]; ++i;
	349	outstr[i] = ctable[d]; ++i;
[1]	350	}
	351	p += 3;
	352	}
	353	}
	354	}
[11]	355	else if (*p == '&')
[1]	356	{
	357	++p;
[18]	358	if (!p \|\| !(*p))
	359	{
	360	outstr[i] = '&'; ++i;
	361	break;
	362	}
[1]	363
	364	if (p[0] == 'a' && p[1] == 'm' && p[2] == 'p' && p[3] == ';')
	365	{
[12]	366	SH_PUT_4(&outstr[i], '=', '2', '6');
[1]	367	i+=3; p += 4;
	368	}
	369	else if (p[0] == 'q' && p[1] == 'u' && p[2] == 'o' && p[3] == 't' &&
	370	p[4] == ';')
	371	{
[12]	372	SH_PUT_4(&outstr[i], '=', '2', '2');
[1]	373	i+=3; p += 5;
	374	}
	375	else if (p[0] == 'l' && p[1] == 't' && p[2] == ';')
	376	{
[12]	377	SH_PUT_4(&outstr[i], '=', '3', 'c');
[1]	378	i+=3; p += 3;
	379	}
	380	else if (p[0] == 'g' && p[1] == 't' && p[2] == ';')
	381	{
[12]	382	SH_PUT_4(&outstr[i], '=', '3', 'e');
[1]	383	i+=3; p += 3;
	384	}
	385	else /* conserve the '&' */
	386	{
	387	outstr[i] = '&'; ++i;
	388	}
[11]	389	}
	390	else
	391	{
	392	outstr[i] = *p; ++i;
	393	++p;
	394	}
[1]	395	} /* while (p && p) /
[11]	396
	397	end:
[1]	398
	399	outstr[i] = '\0';
	400	SL_RETURN( outstr, _("sh_tools_safe_name"));
	401	}
	402
	403
	404	/* extern int h_errno; */
	405
[132]	406	char * sh_tools_errmessage (int tellme, char * errbuf, size_t len)
[1]	407	{
[132]	408	char * p = NULL;
[1]	409	#ifdef HOST_NOT_FOUND
	410	if (tellme == HOST_NOT_FOUND)
[132]	411	p = _("The specified host is unknown: ");
[1]	412	#endif
	413	#ifdef NO_ADDRESS
	414	if (tellme == NO_ADDRESS)
[132]	415	p = _("The requested name is valid but does not have an IP address: ");
[1]	416	#endif
	417	#ifdef NO_RECOVERY
	418	if (tellme == NO_RECOVERY)
[132]	419	p = _("A non-recoverable name server error occurred: ");
[1]	420	#endif
	421	#ifdef TRY_AGAIN
	422	if (tellme == TRY_AGAIN)
[132]	423	p = _("A temporary error occurred on an authoritative name server. The specified host is unknown: ");
[1]	424	#endif
[132]	425	if (!p) p = _("Unknown error");
	426	sl_strlcpy(errbuf, p, len);
	427	return errbuf;
[1]	428	}
	429
	430	int is_numeric (const char * address)
	431	{
	432	int j;
	433	int len = sl_strlen(address);
	434
	435	for (j = 0; j < len; ++j)
	436	if ( (address[j] < '0' \|\| address[j] > '9') && address[j] != '.')
	437	return (1 == 0);
	438	return (1 == 1);
	439	}
	440
	441	#if defined (SH_WITH_SERVER)
	442
	443	int get_open_max ()
	444	{
	445	int value;
	446
	447	#ifdef _SC_OPEN_MAX
	448	value = sysconf (_SC_OPEN_MAX);
	449	#else
	450	#ifdef OPEN_MAX
	451	value = OPEN_MAX;
	452	#else
	453	value = _POSIX_OPEN_MAX;
	454	#endif
	455	#endif
	456
	457	if (value < 0)
	458	value = 8; /* POSIX lower limit */
	459
	460	if (value > 4096)
	461	value = 4096;
	462
	463	return value;
	464	}
	465
	466	#endif
	467
	468	typedef struct _sin_cache {
	469	char * address;
	470	struct sockaddr_in sin;
	471	struct _sin_cache * next;
	472	} sin_cache;
	473
	474	static sin_cache * conn_cache = NULL;
	475	static int cached_addr = 0;
	476
	477	void delete_cache()
	478	{
	479	sin_cache * check_cache = conn_cache;
	480	sin_cache * old_entry = conn_cache;
	481
	482	SL_ENTER(_("delete_cache"));
	483
	484	while (check_cache != NULL)
	485	{
	486	old_entry = check_cache;
	487	check_cache = check_cache->next;
	488	SH_FREE(old_entry->address);
	489	SH_FREE(old_entry);
	490	}
	491
	492	cached_addr = 0;
	493
	494	conn_cache = NULL;
	495	SL_RET0(_("delete_cache"));
	496	}
	497
	498	int DoReverseLookup = S_TRUE;
	499
[22]	500	int set_reverse_lookup (const char * c)
[1]	501	{
	502	return sh_util_flagval(c, &DoReverseLookup);
	503	}
	504
	505	int connect_port (char * address, int port,
	506	char * ecall, int * errnum, char * errmsg, int errsiz)
	507	{
	508	struct in_addr haddr; /* host address from numeric */
	509	/* host details returned by the DNS */
	510	struct hostent *host_entry = NULL;
	511	struct sockaddr_in sinr; /* socket to the remote host */
	512
	513	char * host_name;
	514
[170]	515	volatile int fd = (-1);
[1]	516	int status;
[170]	517	volatile int fail = 0;
[1]	518	int cached = 0;
	519
	520	int retval;
[132]	521	char errbuf[SH_ERRBUF_SIZE];
[1]	522
	523	sin_cache * check_cache = conn_cache;
	524
	525	SL_ENTER(_("connect_port"));
	526
	527	/* paranoia -- should not happen
	528	*/
	529	if (cached_addr > 128)
	530	delete_cache();
	531
	532	if (check_cache != NULL)
	533	{
	534	while (check_cache && check_cache->address)
	535	{
	536	if ( 0 == sl_strncmp(check_cache->address,
	537	address, sl_strlen(address)))
	538	{
	539	memcpy (&sinr, &(check_cache->sin), sizeof(struct sockaddr_in));
	540	sinr.sin_family = AF_INET;
	541	sinr.sin_port = htons (port);
	542	cached = 1;
	543	break;
	544	}
	545	if (check_cache->next)
	546	check_cache = check_cache->next;
	547	else
	548	check_cache = NULL;
	549	}
	550	}
	551
	552	/* only use gethostbyname() if neccessary
	553	*/
	554	if (cached == 0)
	555	{
	556	#ifdef HAVE_INET_ATON
	557	if (0 == inet_aton(address, &haddr))
	558	#else
	559	if ((unsigned long)-1 == (haddr.s_addr = inet_addr(address)))
	560	#endif
	561	{
[170]	562	SH_MUTEX_LOCK(mutex_resolv);
	563
[143]	564	host_name = NULL;
	565
[1]	566	host_entry = sh_gethostbyname(address);
	567
	568	if (host_entry == NULL \|\| host_entry->h_addr == NULL)
	569	{
	570	sl_strlcpy(ecall, _("gethostbyname"), SH_MINIBUF);
	571	#ifndef NO_H_ERRNO
	572	*errnum = h_errno;
	573	#else
	574	*errnum = 666;
	575	#endif
[132]	576	(void) sh_tools_errmessage (*errnum, errmsg, errsiz);
[1]	577	sl_strlcat(errmsg, address, errsiz);
	578	fail = (-1);
	579	}
	580	else
	581	{
	582	sinr.sin_family = AF_INET;
	583	sinr.sin_port = htons (port);
	584	sinr.sin_addr = (struct in_addr ) host_entry->h_addr;
	585
	586
	587	/* reverse DNS lookup
	588	*/
	589	if (DoReverseLookup == S_TRUE)
	590	{
	591	if (host_entry->h_name == NULL)
	592	{
	593	host_name = SH_ALLOC(1);
	594	host_name[0] = '\0';
	595	}
	596	else
	597	{
[34]	598	host_name = sh_util_strdup(host_entry->h_name);
[1]	599	}
	600
	601	host_entry = sh_gethostbyaddr ((char *) &sinr.sin_addr,
	602	sizeof(struct in_addr),
	603	AF_INET);
	604	if (host_entry == NULL \|\| host_entry->h_name == NULL)
	605	{
	606	sl_strlcpy(ecall, _("gethostbyaddr"), SH_MINIBUF);
	607	#ifndef NO_H_ERRNO
	608	*errnum = h_errno;
	609	#else
	610	*errnum = 666;
	611	#endif
[132]	612	(void) sh_tools_errmessage (*errnum, errmsg, errsiz);
[1]	613	sl_strlcat(errmsg,
	614	inet_ntoa ((struct in_addr ) &(sinr.sin_addr)),
	615	errsiz);
	616	fail = (-1);
	617	}
	618	else
	619	{
	620	*errnum = 0;
	621	if (sl_strlen(host_entry->h_name) == 0 \|\|
[169]	622	(*errnum = sl_strcasecmp(host_name,host_entry->h_name)) != 0)
[1]	623	{
	624	if (*errnum)
	625	sl_strlcpy(ecall, _("strcmp"), SH_MINIBUF);
	626	else
	627	sl_strlcpy(ecall, _("strlen"), SH_MINIBUF);
[161]	628	sl_strlcpy(errmsg, _("Reverse lookup failed: "),
[1]	629	errsiz);
	630	sl_strlcat(errmsg, address, errsiz);
	631	sl_strlcat(errmsg, _(" vs "), errsiz);
	632	sl_strlcat(errmsg,
	633	inet_ntoa ((struct in_addr ) &(sinr.sin_addr)),
	634	errsiz);
	635	fail = -1;
	636	}
	637	}
	638	}
	639	}
[134]	640	SH_MUTEX_UNLOCK(mutex_resolv);
[143]	641	if (host_name) SH_FREE(host_name);
[1]	642	}
	643
	644	else /* address was numeric */
	645	{
	646	sinr.sin_family = AF_INET;
	647	sinr.sin_port = htons (port);
	648	sinr.sin_addr = haddr;
	649	}
	650
	651
	652	if (fail != -1)
	653	{
	654	/* put it into the cache
	655	*/
	656	check_cache = SH_ALLOC(sizeof(sin_cache));
	657	check_cache->address = SH_ALLOC(sl_strlen(address) + 1);
	658	sl_strlcpy (check_cache->address, address, sl_strlen(address) + 1);
	659	memcpy(&(check_cache->sin), &sinr, sizeof(struct sockaddr_in));
	660	++cached_addr;
	661
	662	if (conn_cache)
	663	{
	664	if (conn_cache->next)
	665	check_cache->next = conn_cache->next;
	666	else
	667	check_cache->next = NULL;
	668	conn_cache->next = check_cache;
	669	}
	670	else
	671	{
	672	check_cache->next = NULL;
	673	conn_cache = check_cache;
	674	}
	675	}
	676	}
	677
	678
	679	if (fail != (-1))
	680	{
	681	fd = socket(AF_INET, SOCK_STREAM, 0);
	682	if (fd < 0) {
	683	fail = (-1);
	684	status = errno;
	685	sl_strlcpy(ecall, _("socket"), SH_MINIBUF);
	686	*errnum = status;
[132]	687	sl_strlcpy(errmsg, sh_error_message (status, errbuf, sizeof(errbuf)), errsiz);
[1]	688	sl_strlcat(errmsg, _(", address "), errsiz);
	689	sl_strlcat(errmsg, address, errsiz);
	690	}
	691	}
	692
	693	if (fail != (-1)) {
	694
	695	if ( retry_connect(FIL__, __LINE__, fd,
	696	(struct sockaddr *) &sinr, sizeof(sinr)) < 0)
	697	{
	698	status = errno;
	699	sl_strlcpy(ecall, _("connect"), SH_MINIBUF);
	700	*errnum = status;
[132]	701	sl_strlcpy(errmsg, sh_error_message (status, errbuf, sizeof(errbuf)), errsiz);
[1]	702	sl_strlcat(errmsg, _(", address "), errsiz);
	703	sl_strlcat(errmsg, address, errsiz);
	704	close(fd);
	705	fail = (-1);
	706	}
	707	}
	708
	709	retval = (fail < 0) ? (-1) : fd;
	710	SL_RETURN(retval, _("connect_port"));
	711	}
	712
	713	int connect_port_2 (char * address1, char * address2, int port,
	714	char * ecall, int * errnum, char * errmsg, int errsiz)
	715	{
	716	int retval = (-1);
	717
	718	SL_ENTER(_("connect_port_2"));
	719
	720	errmsg[0] = '\0';
	721	*errnum = 0;
	722
	723	if (address1 != NULL && address1[0] != '\0')
	724	retval = connect_port (address1, port,
	725	ecall, errnum,
	726	errmsg, errsiz);
	727
	728	if (retval < 0 && address2 != NULL && address2[0] != '\0')
	729	{
	730	/* can't use sh_error_handle here, as this would cause an infinite
	731	* loop if called from sh_unix_time
	732	*/
	733	TPT(( 0, FIL__, __LINE__, _("msg=<Using alternative server %s.>\n"),
	734	address2));
	735	retval = connect_port (address2, port,
	736	ecall, errnum,
	737	errmsg, errsiz);
	738	}
	739
	740	if ((retval < 0) &&
	741	(address1 == NULL \|\| address1[0] == '\0') &&
	742	(address1 == NULL \|\| address1[0] == '\0'))
	743	{
	744	sl_strlcpy(ecall, _("connect_port_2"), SH_MINIBUF);
	745	sl_strlcpy(errmsg, _("No server address known"), errsiz);
	746	}
	747	SL_RETURN(retval, _("connect_port_2"));
	748	/* return retval; */
	749	}
	750
[27]	751	#if defined(HAVE_NTIME) \|\| defined(SH_WITH_CLIENT) \|\| defined(SH_WITH_SERVER)
[1]	752	static
	753	int sh_write_select(int type, int sockfd,
	754	char *buf, int nbytes,
	755	int * w_error, int timeout)
	756	{
	757	int countbytes, count;
	758	fd_set fds;
	759	struct timeval tv;
	760	int select_now;
	761	int num_sel;
	762
	763	struct sigaction new_act;
	764	struct sigaction old_act;
[132]	765	char errbuf[SH_ERRBUF_SIZE];
[1]	766
	767	SL_ENTER(_("sh_write_select"));
	768
	769	/* ignore SIGPIPE (instead get EPIPE if connection is closed)
	770	*/
	771	new_act.sa_handler = SIG_IGN;
[22]	772	sigemptyset( &new_act.sa_mask ); /* set an empty mask */
	773	new_act.sa_flags = 0; /* init sa_flags */
[1]	774	sigaction (SIGPIPE, &new_act, &old_act);
	775
	776	FD_ZERO(&fds);
	777	FD_SET(sockfd, &fds);
	778
	779	countbytes = 0;
	780	tv.tv_sec = 1;
	781	tv.tv_usec = 0;
	782	select_now = 0;
	783
	784	*w_error = 0;
	785
	786	while ( countbytes < nbytes ) {
	787
	788	FD_ZERO(&fds);
	789	FD_SET(sockfd, &fds);
	790
	791	if (type == SH_DO_WRITE)
	792	{
	793	if ( (num_sel = select (sockfd+1, NULL, &fds, NULL, &tv)) == -1)
	794	{
	795	if (sig_raised == 1)
	796	{
	797	sig_raised = 2;
	798	continue;
	799	}
[171]	800	if ( errno == EINTR \|\| errno == EINPROGRESS ) /* try again */
[1]	801	continue;
	802	*w_error = errno;
	803	sigaction (SIGPIPE, &old_act, NULL);
[171]	804	sh_error_message(*w_error, errbuf, sizeof(errbuf));
	805	sh_error_handle (SH_ERR_INFO, FIL__, __LINE__, errno, MSG_E_SUBGEN,
	806	errbuf,
	807	_("sh_write_select (ws)") );
	808	TPT(( 0, FIL__, __LINE__, _("msg=<select: %s>\n"), errbuf ));
[1]	809	SL_RETURN( countbytes, _("sh_write_select"));
	810	}
	811	}
	812	else
	813	{
	814	if ( (num_sel = select (sockfd+1, &fds, NULL, NULL, &tv)) == -1)
	815	{
	816	if (sig_raised == 1)
	817	{
	818	sig_raised = 2;
	819	continue;
	820	}
[171]	821	if ( errno == EINTR \|\| errno == EINPROGRESS ) /* try again */
[1]	822	continue;
	823	*w_error = errno;
	824	sigaction (SIGPIPE, &old_act, NULL);
[171]	825	sh_error_message(*w_error, errbuf, sizeof(errbuf));
	826	sh_error_handle (SH_ERR_INFO, FIL__, __LINE__, errno, MSG_E_SUBGEN,
	827	errbuf,
	828	_("sh_write_select (rs)") );
	829	TPT(( 0, FIL__, __LINE__, _("msg=<select: %s>\n"), errbuf ));
[1]	830	SL_RETURN( countbytes, _("sh_write_select"));
	831	}
	832	}
	833
	834	/* on Linux, timeout is modified to reflect the amount of
	835	* time not slept
	836	*/
	837	tv.tv_sec = 1;
	838	tv.tv_usec = 0;
	839
	840
	841	/* let's not hang on forever
	842	*/
	843	if (num_sel == 0)
	844	{
	845	++select_now; /* timeout */
	846	if ( select_now > timeout ) /* 5 minutes */
	847	{
	848	#ifdef ETIMEDOUT
	849	*w_error = ETIMEDOUT;
	850	#else
	851	*w_error = 0;
	852	#endif
	853	sigaction (SIGPIPE, &old_act, NULL);
	854	TPT(( 0, FIL__, __LINE__, _("msg=<Timeout>\n")));
	855	SL_RETURN( countbytes, _("sh_write_select"));
	856	}
	857	}
	858
	859	if ( FD_ISSET (sockfd, &fds) )
	860	{
	861	if (type == SH_DO_WRITE)
	862	count = write (sockfd, buf, nbytes-countbytes);
	863	else
	864	count = read (sockfd, buf, nbytes-countbytes);
	865
	866	if (count > 0)
	867	{
	868	countbytes += count;
	869	buf += count; /* move buffer pointer forward */
	870	if (countbytes < nbytes) FD_SET( sockfd, &fds );
	871	}
	872	else if (count < 0 && errno == EINTR)
	873	{
	874	FD_SET( sockfd, &fds );
	875	}
	876	else if (count < 0)
	877	{
	878	*w_error = errno;
	879	sigaction (SIGPIPE, &old_act, NULL);
[171]	880	sh_error_message(*w_error, errbuf, sizeof(errbuf));
	881	sh_error_handle (SH_ERR_INFO, FIL__, __LINE__, errno, MSG_E_SUBGEN,
	882	errbuf,
	883	(type == SH_DO_WRITE) ?
	884	_("sh_write_select (w)") : _("sh_write_select (r)"));
[1]	885	TPT(( 0, FIL__, __LINE__, _("msg=<count < 0>\n")));
	886	SL_RETURN( countbytes, _("sh_write_select"));
	887	}
	888	else /* count == 0 */
	889	{
	890	*w_error = errno;
	891	sigaction (SIGPIPE, &old_act, NULL);
	892	TPT(( 0, FIL__, __LINE__, _("msg=<count == 0>\n")));
	893	SL_RETURN( countbytes, _("sh_write_select"));
	894	}
	895	}
	896	}
	897
	898
	899	/* restore signal handler
	900	*/
	901	sigaction (SIGPIPE, &old_act, NULL);
	902
	903	*w_error = 0;
	904
	905	TPT(( 0, FIL__, __LINE__, _("msg=<count = %d>\n"), countbytes));
	906	SL_RETURN( countbytes, _("sh_write_select"));
	907	}
	908	#endif
	909
[27]	910	#if defined (SH_WITH_CLIENT) \|\| defined(SH_WITH_SERVER)
[1]	911	unsigned long write_port (int sockfd, char *buf, unsigned long nbytes,
	912	int * w_error, int timeout)
	913	{
	914	unsigned long bytes;
	915
	916	SL_ENTER(_("write_port"));
	917
	918	bytes = sh_write_select(SH_DO_WRITE, sockfd, buf, nbytes, w_error, timeout);
	919	if (*w_error != 0)
	920	{
[132]	921	char errbuf[SH_ERRBUF_SIZE];
[1]	922	sh_error_handle((-1), FIL__, __LINE__, *w_error, MSG_TCP_NETRP,
[132]	923	sh_error_message (*w_error, errbuf, sizeof(errbuf)),
	924	(long) sockfd, _("write_port"));
[1]	925	}
	926	SL_RETURN( bytes, _("write_port"));
	927	}
	928	#endif
	929
[27]	930	#if defined(HAVE_NTIME) \|\| defined(SH_WITH_CLIENT) \|\| defined(SH_WITH_SERVER)
[1]	931
	932	unsigned long read_port (int sockfd, char *buf, unsigned long nbytes,
	933	int * w_error, int timeout)
	934	{
	935	unsigned long bytes;
	936
	937	SL_ENTER(_("read_port"));
	938
	939	bytes = sh_write_select(SH_DO_READ, sockfd, buf, nbytes, w_error, timeout);
	940	if (*w_error != 0)
	941	{
[132]	942	char errbuf[SH_ERRBUF_SIZE];
[1]	943	sh_error_handle((-1), FIL__, __LINE__, *w_error, MSG_TCP_NETRP,
[132]	944	sh_error_message (*w_error, errbuf, sizeof(errbuf)),
	945	(long) sockfd, _("read_port"));
[1]	946	}
	947	SL_RETURN( bytes, _("read_port"));
	948	}
	949	#endif
	950
	951	#if defined(SH_WITH_CLIENT) \|\| defined(SH_WITH_SERVER)
	952
	953	int check_request_nerr (char * have, char * need)
	954	{
	955	SL_ENTER(_("check_request_nerr"));
	956	ASSERT_RET((have != NULL && need != NULL),
	957	_("have != NULL && need != NULL"), (-1))
	958
	959	if ( (have[0] == need[0]) && (have[1] == need[1]) &&
	960	(have[2] == need[2]) && (have[3] == need[3]))
	961	SL_RETURN(0, _("check_request_nerr"));
	962	SL_RETURN((-1), _("check_request_nerr"));
	963	}
	964	#endif
	965
[27]	966	#if defined (SH_WITH_CLIENT) \|\| defined(SH_WITH_SERVER)
[1]	967
	968	int check_request (char * have, char * need)
	969	{
	970	char first[21], second[5];
	971	int i;
	972
	973	SL_ENTER(_("check_request"));
	974	i = check_request_nerr (have, need);
	975
	976	if (i == 0)
	977	SL_RETURN(0, _("check_request"));
	978
	979	for (i = 0; i < 4; ++i)
	980	{
	981	second[i] = need[i];
	982	sprintf(&first[i4], _("%c%03o"), / known to fit */
	983	'\\', (unsigned char) have[i]);
	984	}
	985
	986	first[20] = '\0'; second[4] = '\0';
	987
	988	sh_error_handle((-1), FIL__, __LINE__, EINVAL, MSG_E_NETST,
	989	second, first);
	990	SL_RETURN((-1), _("check_request"));
	991	}
	992	#endif
	993
	994	#if defined (SH_WITH_SERVER)
	995
	996	int check_request_s (char * have, char * need, char * clt)
	997	{
	998	char first[21], second[5];
	999	int i;
	1000
	1001	SL_ENTER(_("check_request_s"));
	1002	i = check_request_nerr (have, need);
	1003
	1004	if (i == 0)
	1005	SL_RETURN( (0), _("check_request_s"));
	1006
	1007	for (i = 0; i < 4; ++i)
	1008	{
	1009	second[i] = need[i];
	1010	sprintf(&first[i4], _("%c%03o"), / known to fit */
	1011	'\\', (unsigned char) have[i]);
	1012	}
	1013	first[20] = '\0'; second[4] = '\0';
	1014	sh_error_handle((-1), FIL__, __LINE__, EINVAL, MSG_E_NETST1,
	1015	second, first, clt);
	1016	SL_RETURN( (-1), _("check_request_s"));
	1017	}
	1018	#endif
	1019
[27]	1020	#if defined (SH_WITH_CLIENT) \|\| defined (SH_WITH_SERVER)
[1]	1021
	1022	void get_header (unsigned char * head, unsigned long * bytes, char * u)
	1023	{
	1024	SL_ENTER(_("get_header"));
	1025
	1026	*bytes =
	1027	(256 * (unsigned int)head[1] + (unsigned int)head[2]);
	1028
	1029	if (u != NULL)
	1030	{
	1031	u[0] = head[3];
	1032	u[1] = head[4];
	1033	u[2] = head[5];
	1034	u[3] = head[6];
	1035	u[4] = '\0';
	1036	}
	1037
	1038	SL_RET0(_("get_header"));
	1039	}
	1040	#endif
	1041
	1042	#if defined(SH_WITH_CLIENT) \|\| defined(SH_WITH_SERVER)
	1043
	1044	#ifdef SH_ENCRYPT_2
	1045	#define TRANS_BYTES 65120
	1046	#else
	1047	#define TRANS_BYTES 65280
	1048	#endif
	1049
	1050	void put_header (unsigned char * head, int protocol,
	1051	unsigned long * length, char * u)
	1052	{
	1053
	1054	/* static long transfer_limit = (8 * SH_BUFSIZE); V0.8 */
	1055	static unsigned long transfer_limit = TRANS_BYTES + 6 + KEY_LEN;
	1056
	1057	SL_ENTER(_("put_header"));
	1058
	1059	head[0] = protocol;
	1060
	1061	ASSERT((length < transfer_limit), _("length < transfer_limit"))
	1062
	1063	if (*length > transfer_limit)
	1064	*length = transfer_limit;
	1065
	1066	head[1] = (unsigned int)(*length/256);
	1067	head[2] = (unsigned int)(length-256 head[1]);
	1068	if (u == NULL)
	1069	{
	1070	head[3] = 0x01;
	1071	head[4] = 0x01;
	1072	head[5] = 0x01;
	1073	head[6] = 0x01;
	1074	}
	1075	else
	1076	{
	1077	head[3] = u[0];
	1078	head[4] = u[1];
	1079	head[5] = u[2];
	1080	head[6] = u[3];
	1081	}
	1082
	1083	SL_RET0(_("put_header"));
	1084	}
	1085	#endif
	1086
	1087	/* ------------------------------------------
	1088	*
	1089	* version 2 client/server protocol
	1090	*
	1091	* ------------------------------------------
	1092	*
	1093	* header : flag size[2]
	1094	*
	1095	* payload: random_pad[8] protocol[4] size[4] payload[payload_size] padding
	1096	*
	1097	* full_size <= 8192; payload_size <= 8176 (51116); msg_size <= 8128 (50816)
	1098	* (msg_size = payload_size - key_len = payload_size - 48)
	1099	*/
[27]	1100
	1101	/*
	1102	* only SH_V2_FULLSIZE is used, and only once
	1103	*/
	1104	#if 0
[1]	1105	#ifdef SH_WITH_SERVER
	1106	#define SH_V2_FULLSIZE 240
	1107	#define SH_V2_PAYLOAD 224
	1108	#define SH_V2_MESSAGE 176
	1109	#else
	1110	#define SH_V2_FULLSIZE 1024
	1111	#define SH_V2_PAYLOAD 1008
	1112	#define SH_V2_MESSAGE 960
	1113	#endif
[27]	1114	#endif
	1115	#define SH_V2_FULLSIZE 1024
[1]	1116
	1117	#ifdef SH_ENCRYPT
	1118	#include "rijndael-api-fst.h"
	1119	#endif
	1120
	1121	void sh_tools_show_header (unsigned char * head, char sign)
	1122	{
	1123	#define SH_IS_ASCII(c) (((c) & ~0x7f) == 0)
	1124
	1125
	1126	int msg_size = (256 * (unsigned int)head[1] + (unsigned int)head[2]);
	1127	char code[32];
	1128	char * p = &code[0];
	1129
	1130	memset (code, ' ', 32); /* space */
	1131
	1132	if ((head[0] & SH_PROTO_SRP) != 0) { p[0]='S';p[1]='R';p[2]='P';}
	1133	p += 4;
	1134	if ((head[0] & SH_PROTO_MSG) != 0) { p[0]='M';p[1]='S';p[2]='G';}
	1135	p += 4;
	1136	if ((head[0] & SH_PROTO_BIG) != 0) { p[0]='B';p[1]='I';p[2]='G';}
	1137	p += 4;
	1138	if ((head[0] & SH_PROTO_END) != 0) { p[0]='E';p[1]='N';p[2]='D';}
	1139	p += 4;
	1140	if ((head[0] & SH_PROTO_ENC) != 0) { p[0]='E';p[1]='N';p[2]='C';}
	1141	p += 4;
	1142	if ((head[0] & SH_PROTO_EN2) != 0) { p[0]='E';p[1]='N';p[2]='2';}
	1143	code[23] = '\0';
	1144
	1145	if (SH_IS_ASCII(head[3]) && isalpha(head[3]) &&
	1146	SH_IS_ASCII(head[4]) && isalpha(head[4]) &&
	1147	SH_IS_ASCII(head[5]) && isalpha(head[5]) &&
	1148	SH_IS_ASCII(head[6]) && isalpha(head[6])) {
	1149	fprintf(stderr, "%c %3o %s %5d %c %c %c %c\n", sign,
	1150	head[0], code, msg_size, head[3], head[4], head[5], head[6]);
	1151	} else {
	1152	fprintf(stderr, "%c %3o %s %5d %2X %2X %2X %2X\n", sign,
	1153	head[0], code, msg_size, head[3], head[4], head[5], head[6]);
	1154	}
	1155	return;
	1156	}
	1157
	1158	#ifdef SH_ENCRYPT
	1159	/*
	1160	* #define DEBUG_EN2
	1161	*
	1162	* ingest version 1 7-byte header and payload, return version2 header/payload
	1163	* last 4 bytes of outgoing header are set to dummy value
	1164	*/
	1165	char * sh_tools_makePack (unsigned char * header,
[34]	1166	char * payload, unsigned long payload_size,
[1]	1167	keyInstance * keyInstE)
	1168	{
	1169	UINT32 rpad[3];
	1170	unsigned char head[16];
	1171	double epad;
[34]	1172	unsigned long i_epad = 0;
	1173	unsigned long i_blk = payload_size / 16;
	1174	unsigned long i_blkmax = SH_V2_FULLSIZE / 16;
	1175	unsigned long pads = 0;
	1176	size_t full_size;
[1]	1177	char * full_ret;
	1178
	1179	char * p;
	1180	RIJ_BYTE inBlock[B_SIZ];
	1181	RIJ_BYTE outBlock[B_SIZ];
	1182	int j;
	1183	cipherInstance cipherInst;
	1184	int err_num;
	1185	int blkfac;
[34]	1186	int oflow = 0;
[1]	1187
	1188	/*
	1189	SL_REQUIRE (i_blk*16 == payload_size, _("payload_size % 16 != 0"));
	1190	*/
	1191	if ((i_blk * 16) != payload_size) ++i_blk;
	1192	#ifdef DEBUG_EN2
	1193	fprintf(stderr, "SEND <%d> blocks <%d>\n", payload_size, i_blk);
	1194	#endif
	1195	/* random_pad
	1196	*/
[137]	1197	rpad[1] = taus_get ();
[1]	1198	memcpy (head, &rpad[1], 4);
[137]	1199	rpad[0] = taus_get ();
[1]	1200	memcpy (&head[4], &rpad[0], 4);
[137]	1201	rpad[2] = taus_get ();
[1]	1202	memcpy (&head[8], &rpad[2], 4);
	1203
	1204	/* protocol
	1205	*/
	1206	/* memcpy (&head[8], &header[3], 4); */
	1207
	1208	/* size (payload)
	1209	*/
	1210	head[12] = header[1];
	1211	head[13] = header[2];
	1212	head[14] = '\0';
	1213	head[15] = '\0';
	1214
	1215	if (i_blk < i_blkmax)
	1216	{
	1217	pads = i_blkmax - i_blk;
	1218	/* memcpy((char ) &rpad[2], &head[12], 4); /
	1219	epad = taus_get_double (&rpad);
	1220	#ifdef DEBUG_EN2
	1221	fprintf(stderr, "PAD1 <%d> <%f>\n", pads, epad);
	1222	#endif
[34]	1223	i_epad = (unsigned long) (pads * epad);
[1]	1224	#ifdef DEBUG_EN2
	1225	fprintf(stderr, "PAD2 <%d> <%d>\n", i_epad, (i_epad*16));
	1226	#endif
	1227	}
	1228
[34]	1229	full_size = 16; /* head */
	1230	if (sl_ok_muls(i_blk, 16) && sl_ok_adds(full_size, (i_blk*16)))
	1231	full_size = full_size + (i_blk16); / payload */
	1232	else
	1233	oflow = 1;
	1234	if (sl_ok_adds(full_size, (i_epad*16)))
	1235	full_size = full_size + (i_epad16); / pad */
	1236	else
	1237	i_epad = 0;
[1]	1238
[34]	1239	if (oflow)
	1240	{
	1241	sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
	1242	_("integer overflow"),
	1243	_("sh_tools_makePack"));
	1244	}
	1245
[1]	1246	full_ret = SH_ALLOC(full_size);
	1247	memcpy(full_ret, head, 16);
[34]	1248	if (payload != NULL && !oflow)
[1]	1249	{
	1250	memcpy(&full_ret[16], payload, payload_size);
	1251	}
[34]	1252	if ((i_blk*16) > payload_size && !oflow)
[1]	1253	{
	1254	#ifdef DEBUG_EN2
	1255	fprintf(stderr, "SEN2 <%d>\n", (i_blk*16) - payload_size);
	1256	#endif
	1257	memset(&full_ret[16+payload_size], '\0', (i_blk*16) - payload_size);
	1258	payload_size = i_blk * 16;
	1259	}
	1260	memset(&full_ret[16+payload_size], '\0', i_epad*16);
	1261	#ifdef DEBUG_EN2
	1262	fprintf(stderr, "SEN3 <%d> <%d>\n", full_size, i_epad*16);
	1263	#endif
	1264
	1265	/* rewrite header
	1266	*/
	1267	header[1] = (unsigned int)(full_size/256);
	1268	header[2] = (unsigned int)(full_size - (256 * header[1]));
	1269	/* don't erase protocol from header
	1270	memset(&header[3], '\0', 4);
	1271	*/
	1272	p = full_ret; blkfac = full_size / 16;
	1273
	1274	err_num = cipherInit (&cipherInst, MODE_CBC, NULL);
	1275
	1276	if (err_num < 0)
	1277	{
[132]	1278	char expbuf[SH_ERRBUF_SIZE];
[1]	1279	sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
[132]	1280	errorExplain(err_num, expbuf, sizeof(expbuf)),
[1]	1281	_("sh_tools_makePack: cipherInit"));
	1282	}
	1283	for (j = 0; j < blkfac; ++j)
	1284	{
	1285	memcpy(inBlock, p, B_SIZ);
	1286	err_num = blockEncrypt(&cipherInst, keyInstE,
	1287	inBlock, 128 * BNUM, outBlock);
	1288	if (err_num < 0)
	1289	{
[132]	1290	char expbuf[SH_ERRBUF_SIZE];
[1]	1291	sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
[132]	1292	errorExplain(err_num, expbuf, sizeof(expbuf)),
[1]	1293	_("sh_tools_makePack: blockEncrypt"));
	1294	}
	1295	memcpy(p, outBlock, B_SIZ);
	1296	p += B_SIZ;
	1297	}
	1298
	1299	return full_ret;
	1300	}
	1301
	1302	/* write a 7-byte header and return payload as expected by version 1
	1303	* last 4 bytes of incoming header are dummy
	1304	*/
	1305	char * sh_tools_revertPack (unsigned char * header, char * message,
	1306	keyInstance * keyInstD,
	1307	unsigned long message_size)
	1308	{
	1309	unsigned long msg_size;
	1310	char * msg_ret;
	1311
	1312	char * p;
	1313	RIJ_BYTE inBlock[B_SIZ];
	1314	RIJ_BYTE outBlock[B_SIZ];
	1315	int j;
	1316	cipherInstance cipherInst;
	1317	int err_num;
	1318	int blkfac;
[132]	1319	char expbuf[SH_ERRBUF_SIZE];
[1]	1320
	1321	msg_size = (256 * (unsigned int)header[1] + (unsigned int)header[2]);
	1322	#ifdef DEBUG_EN2
	1323	fprintf(stderr, "RECV <%lu>\n", msg_size);
	1324	#endif
	1325	if (msg_size > message_size) {
	1326	msg_size = message_size;
	1327	#ifdef DEBUG_EN2
	1328	fprintf(stderr, "RECV TRUNC1 <%lu>\n", msg_size);
	1329	#endif
	1330	}
	1331
	1332	p = message; blkfac = msg_size / 16;
	1333
	1334	err_num = cipherInit (&cipherInst, MODE_CBC, NULL);
	1335
	1336	if (err_num < 0)
	1337	{
	1338	sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
[132]	1339	errorExplain(err_num, expbuf, sizeof(expbuf)),
[1]	1340	_("sh_tools_revertPack: cipherInit"));
	1341	}
	1342	for (j = 0; j < blkfac; ++j)
	1343	{
	1344	memcpy(inBlock, p, B_SIZ);
	1345	err_num = blockDecrypt(&cipherInst, keyInstD,
	1346	inBlock, 128 * BNUM, outBlock);
	1347	if (err_num < 0)
	1348	{
	1349	sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
[132]	1350	errorExplain(err_num, expbuf, sizeof(expbuf)),
[1]	1351	_("sh_tools_revertPack: blockDecrypt"));
	1352	}
	1353	memcpy(p, outBlock, B_SIZ);
	1354	p += B_SIZ;
	1355	}
	1356
	1357	/* rewrite size in header
	1358	*/
	1359	header[1] = message[12];
	1360	header[2] = message[13];
	1361	msg_size = (256 * (unsigned int)header[1] + (unsigned int)header[2]);
	1362
	1363	if (msg_size > (message_size-16))
	1364	{
	1365	msg_size = message_size-16;
	1366	header[1] = (unsigned int)(msg_size/256);
	1367	header[2] = (unsigned int)(msg_size - (256 * header[1]));
	1368	#ifdef DEBUG_EN2
	1369	fprintf(stderr, "RECV TRUNC2 <%lu>\n", msg_size);
	1370	#endif
	1371	}
	1372	#ifdef DEBUG_EN2
	1373	fprintf(stderr, "REC2 <%lu>\n", msg_size);
	1374	#endif
	1375	/* protocol
	1376	*/
	1377	/* memcpy(&header[3], &message[8], 4); */
	1378
	1379	/* payload
	1380	*/
	1381	msg_ret = SH_ALLOC(msg_size+1);
	1382	if (msg_size > 0)
	1383	{
	1384	memcpy(msg_ret, &message[16], msg_size);
	1385	}
	1386	msg_ret[msg_size] = '\0';
	1387	#ifdef DEBUG_EN2
	1388	fprintf(stderr, "REC3 <%lu>\n", msg_size);
	1389	#endif
	1390	SH_FREE(message);
	1391
	1392	return msg_ret;
	1393	}
	1394	#endif
	1395
	1396	int sh_tools_hash_add(char * key, char * buf, int buflen)
	1397	{
	1398	char * theSig;
[133]	1399	char sigbuf[KEYBUF_SIZE];
[1]	1400
	1401	SL_ENTER(_("sh_tools_hash_add"));
	1402
[133]	1403	theSig = sh_util_siggen (key, buf, buflen, sigbuf, sizeof(sigbuf));
[1]	1404	sl_strlcat(buf, theSig, buflen + KEY_LEN + 1);
	1405
	1406	SL_RETURN((0), _("sh_tools_hash_add"));
	1407	}
	1408
	1409
	1410	/* return 0 (== FALSE) if no match, else 1 (== TRUE)
	1411	*/
	1412	int sh_tools_hash_vfy(char * key, char * buf, int buflen)
	1413	{
	1414	char hash[KEY_LEN+1];
	1415	register int i;
	1416	char * theSig;
[133]	1417	char sigbuf[KEYBUF_SIZE];
[1]	1418
	1419	SL_ENTER(_("sh_tools_hash_vfy"));
	1420
[133]	1421	theSig = sh_util_siggen (key, buf, buflen, sigbuf, sizeof(sigbuf));
[1]	1422	sl_strlcpy(hash, theSig, KEY_LEN+1);
	1423
	1424	for (i = 0; i < KEY_LEN; ++i)
	1425	{
	1426	if (buf[buflen + i] != hash[i])
	1427	SL_RETURN((0), _("sh_tools_hash_vfy"));
	1428	}
	1429
	1430	SL_RETURN((1), _("sh_tools_hash_vfy"));
	1431	}
	1432
	1433	/* ------------------------------------------ */
	1434
	1435	#if defined (SH_WITH_SERVER)
	1436
	1437	/* add a checksum to a buffer; put checksum in front
	1438	*/
	1439	char * hash_me (char * key, char * buf, int buflen)
	1440	{
	1441	char hash[KEY_LEN+1];
[34]	1442	char * temp = NULL;
[1]	1443	register int i;
	1444	int total = 0;
	1445	char * theSig;
[133]	1446	char sigbuf[KEYBUF_SIZE];
[1]	1447
	1448
	1449	SL_ENTER(_("hash_me"));
	1450
	1451	#ifdef DEBUG_EN2
	1452	fprintf(stderr, "hash_me <%s> <%d>\n",
	1453	(key == NULL) ? "NULL" : key, buflen);
	1454	#endif
	1455	/* key = H(NSRV,NCLT,SK)
	1456	*/
	1457	ASSERT_RET((key != NULL), _("key != NULL"), (NULL));
	1458	ASSERT_RET((buflen >= 0), _("buflen >= 0"), (NULL));
	1459
[133]	1460	theSig = sh_util_siggen (key, buf, buflen, sigbuf, sizeof(sigbuf));
[1]	1461	sl_strlcpy(hash, theSig, KEY_LEN+1);
	1462
[34]	1463	if (sl_ok_adds(buflen, KEY_LEN))
	1464	{
	1465	total = KEY_LEN + buflen;
	1466	temp = SH_ALLOC (total);
[1]	1467
[34]	1468	for (i = 0; i < KEY_LEN; ++i)
	1469	temp[i] = hash[i];
[1]	1470
[34]	1471	for (i = 0; i < buflen; ++i)
	1472	temp[i+KEY_LEN] = buf[i];
	1473	}
	1474	else
	1475	{
	1476	sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
	1477	_("integer overflow"),
	1478	_("hash_me"));
	1479	temp = sh_util_strdup(buf);
	1480	}
[1]	1481	SL_RETURN(temp, _("hash_me"));
	1482	}
	1483	#endif
	1484
[27]	1485	#if defined(SH_WITH_CLIENT) \|\| defined(SH_WITH_SERVER)
[1]	1486
	1487	/* verify the checksum of a buffer; checksum comes first
	1488	*/
	1489	int hash_check(char * key,
	1490	char * buf, int buflen)
	1491	{
	1492	char hash[KEY_LEN+1];
	1493	register int i;
	1494	char * theSig;
[133]	1495	char sigbuf[KEYBUF_SIZE];
[1]	1496
	1497	SL_ENTER(_("hash_check"));
	1498
	1499	#ifdef DEBUG_EN2
	1500	fprintf(stderr, "hash_check <%s> <%d>\n",
	1501	(key == NULL) ? "NULL" : key, buflen);
	1502	#endif
[133]	1503	theSig = sh_util_siggen (key, &buf[KEY_LEN], buflen-KEY_LEN,
	1504	sigbuf, sizeof(sigbuf));
[1]	1505	sl_strlcpy(hash, theSig, KEY_LEN+1);
	1506
	1507	for (i = 0; i < KEY_LEN; ++i)
	1508	{
	1509	if (buf[i] != hash[i])
	1510	SL_RETURN((-1), _("hash_check"));
	1511	}
	1512	SL_RETURN((0), _("hash_check"));
	1513	}
	1514
	1515	#endif
	1516
	1517	#if defined (SH_WITH_SERVER)
	1518
	1519	char * get_client_conf_file (char * peer, unsigned long * length)
	1520	{
	1521	char * ret;
[34]	1522	int status;
[1]	1523	struct stat buf;
	1524	char * base;
[34]	1525	size_t size;
[1]	1526
	1527	SL_ENTER(_("get_client_conf_file"));
	1528
[34]	1529	base = sh_util_strdup(DEFAULT_DATAROOT);
[1]	1530
[34]	1531	size = sl_strlen(base);
	1532	if (sl_ok_adds(size, sl_strlen(peer)))
	1533	size += sl_strlen(peer);
	1534	if (sl_ok_adds(size, 6))
	1535	size += 6;
[1]	1536
	1537	ret = SH_ALLOC(size);
	1538	sl_strlcpy(ret, base, size);
	1539	sl_strlcat(ret, _("/rc."), size);
	1540	sl_strlcat(ret, peer, size);
	1541
	1542	status = retry_stat (FIL__, __LINE__, ret, &buf);
	1543
	1544	if (status == 0)
	1545	goto lab_end;
	1546	else
	1547	sh_error_handle(SH_ERR_WARN, FIL__, __LINE__, status, MSG_E_ACCESS,
	1548	(long) sh.effective.uid, ret);
	1549
	1550	sl_strlcpy(ret, base, size);
	1551	sl_strlcat(ret, "/rc", size);
	1552
	1553	status = retry_stat (FIL__, __LINE__, ret, &buf);
	1554
	1555	if (status == 0)
	1556	goto lab_end;
	1557	else
	1558	sh_error_handle(SH_ERR_ERR, FIL__, __LINE__, status, MSG_E_ACCESS,
	1559	(long) sh.effective.uid, ret);
	1560
	1561	SH_FREE(base);
[34]	1562	SH_FREE(ret);
[1]	1563	*length=0;
	1564	SL_RETURN(NULL, _("get_client_conf_file"));
	1565
	1566	lab_end:
	1567	if (buf.st_size > 0x7fffffff)
	1568	{
	1569	sh_error_handle(SH_ERR_ERR, FIL__, __LINE__, status, MSG_E_SUBGEN,
	1570	_("File too large"), _("get_client_conf_file"));
	1571	SH_FREE(base);
	1572	SL_RETURN(NULL, _("get_client_conf_file"));
	1573	}
	1574	*length = (unsigned long) buf.st_size;
	1575	SH_FREE(base);
	1576	SL_RETURN(ret, _("get_client_conf_file"));
	1577	}
	1578
	1579	char * get_client_data_file (char * peer, unsigned long * length)
	1580	{
	1581	char * ret;
[34]	1582	int status;
[1]	1583	struct stat buf;
	1584
	1585	char * base;
[34]	1586	size_t size;
[1]	1587
	1588	SL_ENTER(_("get_client_data_file"));
	1589
[34]	1590	base = sh_util_strdup(DEFAULT_DATAROOT);
[1]	1591
[34]	1592	size = sl_strlen(base);
	1593	if (sl_ok_adds(size, sl_strlen(peer)))
	1594	size += sl_strlen(peer);
	1595	if (sl_ok_adds(size, 8))
	1596	size += 8;
[1]	1597
	1598	ret = SH_ALLOC(size);
	1599	sl_strlcpy(ret, base, size);
	1600	sl_strlcat(ret, _("/file."), size);
	1601	sl_strlcat(ret, peer, size);
	1602
	1603	status = retry_stat (FIL__, __LINE__, ret, &buf);
	1604
	1605	if (status == 0)
	1606	goto lab1_end;
	1607	else
	1608	sh_error_handle(SH_ERR_WARN, FIL__, __LINE__, status, MSG_E_ACCESS,
	1609	(long) sh.effective.uid, ret);
	1610
	1611
	1612	sl_strlcpy(ret, base, size);
	1613	sl_strlcat(ret, _("/file"), size);
	1614
	1615	status = retry_stat (FIL__, __LINE__, ret, &buf);
	1616
	1617	if (status == 0)
	1618	goto lab1_end;
	1619	else
	1620	sh_error_handle(SH_ERR_WARN, FIL__, __LINE__, status, MSG_E_ACCESS,
	1621	(long) sh.effective.uid, ret);
	1622
	1623
	1624	*length = 0;
	1625	SH_FREE(base);
[34]	1626	SH_FREE(ret);
[1]	1627	SL_RETURN(NULL, _("get_client_data_file"));
	1628
	1629	lab1_end:
	1630	if (buf.st_size > 0x7fffffff)
	1631	{
	1632	sh_error_handle(SH_ERR_ERR, FIL__, __LINE__, status, MSG_E_SUBGEN,
	1633	_("File too large"), _("get_client_data_file"));
	1634	SH_FREE(base);
	1635	SL_RETURN(NULL, _("get_client_data_file"));
	1636	}
	1637	*length = (unsigned long) buf.st_size;
	1638	SH_FREE(base);
	1639	SL_RETURN(ret, _("get_client_data_file"));
	1640
	1641	}
	1642	#endif
	1643
[27]	1644	#if defined(SH_WITH_CLIENT) \|\| defined(SH_WITH_SERVER) \|\| defined(SH_STEALTH) \|\| defined(WITH_GPG) \|\| defined(WITH_PGP)
[1]	1645
	1646	/* --------- secure temporary file ------------ */
	1647
	1648	SL_TICKET open_tmp ()
	1649	{
	1650	SL_TICKET fd;
	1651	UINT32 ticks;
	1652	char * file;
	1653	struct stat buf;
	1654	int error;
	1655	int status = BAD;
	1656	char * my_tmp_dir;
[133]	1657	char hashbuf[KEYBUF_SIZE];
[1]	1658
	1659	SL_ENTER(_("open_tmp"));
	1660
	1661	#if defined(SH_TMPDIR)
[34]	1662	my_tmp_dir = sh_util_strdup(SH_TMPDIR);
[1]	1663	#else
	1664	#if defined(SH_WITH_SERVER)
[34]	1665	my_tmp_dir = sh_util_strdup(DEFAULT_LOGDIR);
[1]	1666	#else
[34]	1667	my_tmp_dir = sh_util_strdup(sh.effective.home);
[1]	1668	#endif
	1669	#endif
	1670
	1671	if (0 != tf_trust_check (my_tmp_dir, SL_YESPRIV))
	1672	{
	1673	dlog(1, FIL__, __LINE__,
	1674	_("The directory for temporary files: %s is untrusted, i.e. an\nuntrusted user owns or can write to some directory in the path.\n"),
	1675	my_tmp_dir);
	1676	sh_error_handle ((-1), FIL__, __LINE__, EACCES, MSG_TRUST,
	1677	(long) sh.effective.uid,
	1678	my_tmp_dir);
	1679	SH_FREE(my_tmp_dir);
	1680	aud_exit (FIL__, __LINE__, EXIT_FAILURE);
	1681	}
	1682
	1683	do {
	1684
	1685	/* create random filename in effective users home directory
	1686	*/
[137]	1687	ticks = taus_get ();
[1]	1688	if (my_tmp_dir[0] == '/' && my_tmp_dir[1] == '\0')
	1689	file = sh_util_strconcat (my_tmp_dir,
[133]	1690	sh_tiger_hash( (char *) &ticks, TIGER_DATA, 4,
	1691	hashbuf, sizeof(hashbuf)),
[1]	1692	NULL);
	1693	else
	1694	file = sh_util_strconcat (my_tmp_dir,
	1695	"/",
[133]	1696	sh_tiger_hash( (char *) &ticks, TIGER_DATA, 4,
	1697	hashbuf, sizeof(hashbuf)),
[1]	1698	NULL);
	1699
	1700	/* check whether it already exists (paranoia)
	1701	*/
	1702	errno = 0;
	1703	status = retry_lstat(FIL__, __LINE__, file, &buf);
	1704	error = errno;
	1705
	1706	if ( (status < 0) && (error == ENOENT) ) /* file does not exist */
	1707	status = GOOD;
	1708	else if (status < 0) /* unexpected error condition */
	1709	{
	1710	SH_FREE (file);
	1711	SH_FREE(my_tmp_dir);
[169]	1712	sh_error_handle(SH_ERR_ALL, FIL__, __LINE__, status, MSG_E_SUBGEN,
	1713	_("Error (lstat) while opening temporary file"), _("open_tmp"));
[1]	1714	TPT(( 0, FIL__, __LINE__, _("msg=<Unexpected error %d>\n"), error));
	1715	SL_RETURN((-1), _("open_tmp"));
	1716	}
	1717	else /* file exists */
	1718	{
	1719	status = BAD;
	1720	TPT(( 0, FIL__, __LINE__, _("msg=<Temporary file exists already>\n")));
	1721	}
	1722
	1723	if (status == GOOD)
	1724	{
	1725	if (0 == tf_trust_check (file, SL_YESPRIV))
	1726	status = GOOD;
	1727	else
	1728	{
	1729	status = BAD;
	1730	TPT(( 0, FIL__, __LINE__, _("msg=<Temporary file untrusted>\n")));
	1731	}
	1732	}
	1733
	1734	if (status == BAD)
	1735	SH_FREE (file);
	1736
	1737	} while (status == BAD);
	1738
[248]	1739	fd = sl_open_safe_rdwr (FIL__, __LINE__, file, SL_YESPRIV);
[1]	1740	if (SL_ISERROR(fd))
	1741	{
	1742	sh_error_handle(SH_ERR_ALL, FIL__, __LINE__, fd, MSG_E_SUBGEN,
	1743	_("Error opening temporary file"), _("open_tmp"));
	1744	TPT(( 0, FIL__, __LINE__, _("msg=<Error %d temporary file %s>\n"),
	1745	fd, file));
	1746	}
	1747
	1748
	1749	SH_FREE (file);
	1750	SH_FREE(my_tmp_dir);
	1751
	1752	if (!SL_ISERROR(fd)) {
	1753	sl_unlink(fd);
	1754	}
	1755
	1756	if (!SL_ISERROR(fd))
	1757	SL_RETURN((fd), _("open_tmp"));
	1758	else
	1759	SL_RETURN((-1), _("open_tmp"));
	1760	}
	1761
	1762
	1763	int close_tmp (SL_TICKET fd)
	1764	{
	1765	SL_ENTER(_("close_tmp"));
	1766
	1767	if (SL_ISERROR(sl_close (fd)))
	1768	SL_RETURN((-1), _("close_tmp"));
	1769	SL_RETURN((0), _("close_tmp"));
	1770	}
	1771
	1772	int rewind_tmp (SL_TICKET fd)
	1773	{
	1774	SL_ENTER(_("rewind_tmp"));
	1775
	1776	if (SL_ISERROR(sl_rewind (fd)))
	1777	SL_RETURN((-1), _("rewind_tmp"));
	1778	SL_RETURN((0), _("rewind_tmp"));
	1779	}
	1780	#endif

Note: See TracBrowser for help on using the repository browser.

Download in other formats: