shlib.c

远程控制系统,可以实现局域网内进行远程控制计算机,很方便,并且是学习用的非常好的资料.

#include <stdlib.h>
#include <string.h>

#define RC5_R 12
#define RC5_P 0xb7e15163
#define RC5_Q 0x9e3779b9
#define ROTL(x, c) (((x) << ((c) & 31)) | ((x) >> (32 - ((c) & 31))))
#define ROTR(x, c) (((x) >> ((c) & 31)) | ((x) << (32 - ((c) & 31))))
#define swap(a, b) {UCHAR t; t = *a; *a = *b; *b = t;}

typedef unsigned char UCHAR;
typedef unsigned short USHORT;
typedef unsigned long ULONG;

static ULONG rc5_sbox[RC5_R * 2 + 2];
static int crc_table_empty = 1;
static ULONG crc_table[256];
static char base64_alphabet[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
static UCHAR rc4_sbox[256];
static long holdrand = 1L;

void rc4_key(UCHAR *key, ULONG len)
{
	ULONG i, j, k;

	for (i = 0; i < 256; i++)
		rc4_sbox[i] = (UCHAR)i;

	j = k = 0;

	for (i = 0; i < 256; i++)
	{
		j += key[k] + rc4_sbox[i];

		if (++k >= len)
			k = 0;

		swap(&rc4_sbox[i], &rc4_sbox[j & 255]);
	}
}

void rc4_xor(UCHAR *buf, ULONG len)
{ 
	ULONG i;
	UCHAR j, x, y;
	UCHAR s[256];

	for (i = 0; i < 64; i++)
		((ULONG *)s)[i] = ((ULONG *)rc4_sbox)[i];

	x = y = 0;

	for (i = 0; i < len; i++)
	{
		y += s[++x];
		swap(&s[x], &s[y]);
		j = s[x] + s[y];
		buf[i] ^= s[j];
	}
}

static void make_crc_table()
{
	ULONG c, poly;
	int n, k;
	static const UCHAR p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26};

	/* make exclusive-or pattern from polynomial (0xedb88320L) */
	poly = 0L;

	for (n = 0; n < sizeof(p) / sizeof(UCHAR); n++)
		poly |= 1L << (31 - p[n]);

	for (n = 0; n < 256; n++)
	{
		c = (ULONG)n;

		for (k = 0; k < 8; k++)
			c = c & 1 ? poly ^ (c >> 1) : c >> 1;
		crc_table[n] = c;
	}
}
/* ========================================================================= */
#define DO1(buf) crc = crc_table[((int)crc ^ (*buf++)) & 0xff] ^ (crc >> 8);
#define DO2(buf)  DO1(buf); DO1(buf);
#define DO4(buf)  DO2(buf); DO2(buf);
#define DO8(buf)  DO4(buf); DO4(buf);
/* ========================================================================= */

ULONG crc32(ULONG crc, void *buf, ULONG len)
{
	if (crc_table_empty)
	{
		make_crc_table();
		crc_table_empty = 0;
	}

	crc = crc ^ 0xffffffffL;

	while (len >= 8)
	{
		DO8(((UCHAR *)buf));
		len -= 8;
	}

	while (len--)
		DO1(((UCHAR *)buf));

	return crc ^ 0xffffffffL;
}

ULONG Base64Encode(void *dst, void *src, ULONG len)
{
	UCHAR *p1 = src;
	char *p2 = dst;
	ULONG i, v;

	for (i = 0; i < len; i += 3)
	{
		switch (len - i)
		{
		case 1:
			v = (p1[i] << 16);
			*p2++ = base64_alphabet[v >> 18];
			*p2++ = base64_alphabet[(v >> 12) & 63];
			*p2++ = base64_alphabet[64];
			*p2++ = base64_alphabet[64];
			break;

		case 2:
			v = (p1[i] << 16) | (p1[i + 1] << 8);
			*p2++ = base64_alphabet[v >> 18];
			*p2++ = base64_alphabet[(v >> 12) & 63];
			*p2++ = base64_alphabet[(v >> 6) & 63];
			*p2++ = base64_alphabet[64];
			break;

		default:
			v = (p1[i] << 16) | (p1[i + 1] << 8) | p1[i + 2];
			*p2++ = base64_alphabet[v >> 18];
			*p2++ = base64_alphabet[(v >> 12) & 63];
			*p2++ = base64_alphabet[(v >> 6) & 63];
			*p2++ = base64_alphabet[v & 63];
			break;
		}
	}

	*p2++ = '\0';

	return p2 - (char *)dst;
}

ULONG Base64Decode(void *dst, void *src,ULONG len)
{
	char *p1 = src;
	UCHAR *p2 = dst;
	ULONG i, v, n;
	UCHAR base64_table[256];

	for (i = 0; i < sizeof(base64_table); i++)
		base64_table[i] = 255;

	for (i = 0; i < 64; i++)
		base64_table[base64_alphabet[i]] = (char)i;

	for (i = 0, n = 0; i < len; i++)
	{
		if (base64_table[p1[i]] == 255)
			break;

		v = base64_table[p1[i]] | (v << 6);
		n += 6;

		if (n >= 8)
		{
			n -= 8;
			*p2++ = (UCHAR)(v >> n);
		}
	}

	return p2 - (UCHAR *)dst;
}

void rc5_key(UCHAR *pbKey, ULONG dwLen)
{
	ULONG i, j, k, A, B;
	ULONG *S;
	ULONG L[16];
	ULONG SL, LL;

	SL = (RC5_R + 1) * 2;
	LL = (dwLen + 3) >> 2;
	S = rc5_sbox;
	L[dwLen >> 2] = 0;
	memcpy((UCHAR *)L, pbKey, dwLen);

	S[0] = RC5_P;

	for (i = 1; i < SL; i++)
	{
		S[i] = S[i - 1] + RC5_Q;
	}

	i = (SL > LL ? SL : LL) * 3;
	A = B = j = k = 0;

	for (; i > 0; i--)
	{
		A = S[j] = ROTL(S[j] + (A + B), 3);
		B = L[k] = ROTL(L[k] + (A + B), (A + B));
		if (++j >= SL) j = 0;
		if (++k >= LL) k = 0;
	}
}

static void rc5_encrypt1(UCHAR *pOut, UCHAR *pIn)
{
	ULONG i, A, B;
	ULONG *S;

	S = rc5_sbox;
	A = ((ULONG *)pIn)[0] + S[0];
	B = ((ULONG *)pIn)[1] + S[1];

	for (i = 1; i <= RC5_R; i++)
	{
		A = ROTL(A ^ B, B) + S[2 * i];
		B = ROTL(B ^ A, A) + S[2 * i + 1];
	}

	((ULONG *)pOut)[0] = A;
	((ULONG *)pOut)[1] = B;
}

static void rc5_decrypt1(UCHAR *pOut, UCHAR *pIn)
{
	ULONG i, A, B;
	ULONG *S;

	S = rc5_sbox;
	B = ((ULONG *)pIn)[1];
	A = ((ULONG *)pIn)[0];

	for (i = RC5_R; i > 0; i--)
	{
		B = ROTR(B - S[2 * i + 1], A) ^ A;
		A = ROTR(A - S[2 * i], B) ^ B;
	}

	((ULONG *)pOut)[1] = B - S[1];
	((ULONG *)pOut)[0] = A - S[0];
}

void rc5_encrypt(void *dst, void *src, ULONG len)
{
	ULONG i, m, n;

	if (len < 8)
	{
		for (i = 0; i < len; i++)
			((UCHAR *)dst)[i] = ((UCHAR *)src)[i] ^ (UCHAR)rc5_sbox[i];
		return;
	}

	if (len & 7)
	{
		n = (len & 7) + 8;
		m = len - n;
	}
	else
	{
		n = 0;
		m = len;
	}

	for (i = 0; i < m; i += 8)
	{
		rc5_encrypt1((UCHAR *)dst + i, (UCHAR *)src + i);
	}

	if (n)
	{
		memcpy((UCHAR *)dst + i, (UCHAR *)src + i, n);
		rc5_encrypt1((UCHAR *)dst + i, (UCHAR *)dst + i);
		rc5_encrypt1((UCHAR *)dst + i + n - 8, (UCHAR *)dst + i + n - 8);
	}
}

void rc5_decrypt(void *dst, void *src, ULONG len)
{
	ULONG i, m, n;

	if (len < 8)
	{
		for (i = 0; i < len; i++)
			((UCHAR *)dst)[i] = ((UCHAR *)src)[i] ^ (UCHAR)rc5_sbox[i];
		return;
	}

	if (len & 7)
	{
		n = (len & 7) + 8;
		m = len - n;
	}
	else
	{
		n = 0;
		m = len;
	}

	for (i = 0; i < m; i += 8)
	{
		rc5_decrypt1((UCHAR *)dst + i, (UCHAR *)src + i);
	}

	if (n)
	{
		memcpy((UCHAR *)dst + i, (UCHAR *)src + i, n);
		rc5_decrypt1((UCHAR *)dst + i + n - 8, (UCHAR *)dst + i + n - 8);
		rc5_decrypt1((UCHAR *)dst + i, (UCHAR *)dst + i);
	}
}

void *MemorySearchLR(void *m1, ULONG n1, void *m2, ULONG n2)
{
	UCHAR *s1 = m1;
	UCHAR *s2 = m2;
	ULONG i, index[256];

	if (n1 < n2)
		return NULL;

	if (n2 == 0)
		return m1;

	for (i = 0; i < 256; i++)
		index[i] = n2 + 1;

	for (i = 0; i < n2; i++)
		index[s2[i]] = n2 - i;

	do
	{
		for (i = 0; s1[i] == s2[i]; i++)
		{
			if (i == n2 - 1)
				return s1;
		}

		s1 += index[s1[n2]];
	} while (s1 + n2 <= (char *)m1 + n1);

	return NULL;
}

void *MemorySearchRL(void *m1, ULONG n1, void *m2, ULONG n2)
{
	UCHAR *s1 = m1;
	UCHAR *s2 = m2;
	ULONG i, index[256];

	if (n1 < n2)
		return NULL;

	if (n2 == 0)
		return m1;

	for (i = 0; i < 256; i++)
		index[i] = n2 + 1;

	for (i = n2 - 1; i >= 0; i--)
		index[s2[i]] = n2 - i;

	do
	{
		for (i = n2 - 1; s1[i] == s2[i]; i--)
		{
			if (i == 0)
				return s1;
		}

		s1 -= index[*(s1 - 1)];
	} while (s1 >= (char *)m1 + n2);

	return NULL;
}
#ifdef _DEBUG
size_t strlen(const char *str)
{
	const char *s;
	
	s = str;
	while (*s++);

	return s - str - 1;
}

char *strcpy(char *dst, const char *src)
{
	char *s;
	
	s = dst;
	while (*s++ = *src++);

	return dst;
}

char *strcat(char *dst, const char *src)
{
	char *s;
	
	s = dst;
	while (*s++);
	s -= 1;
	while (*s++ = *src++);

	return dst;
}

int strcmp(const char *str1, const char *str2)
{
	int ret;

	while (!(ret = *str1 - *str2) && *str2)
	{
		str1++;
		str2++;
	}

	return ret;
}
#endif
int stricmp(const char *str1, const char *str2)
{
	unsigned char f, l;
	int ret;

	do
	{
		f = *str1++;
		l = *str2++;
		if ((unsigned char)(f - 0x41) < 26)
			f |= 0x20;
		if ((unsigned char)(l - 0x41) < 26)
			l |= 0x20;
	} while (f && !(ret = f - l));

	return ret;
}

char *strncpy(char *dst, const char *src, size_t len)
{
	char *s;

	s = dst;
	while (len && (*s++ = *src++)) len--;
	while (len--) *s++ = '\0';

	return dst;
}

int strncmp(const char *str1, const char *str2, size_t len)
{
	int ret = 0;

	while (len-- && *str1 && !(ret = *str1 - *str2))
	{
		str1++;
		str2++;
	}

	return ret;
}

int strnicmp(const char *str1, const char *str2, size_t len)
{
	char f, l;
	int ret;

	while (len--)
	{
		f = *str1++;
		l = *str2++;
		if (f >= 'A' && f <= 'Z')
			f += 'a' - 'A';
		if (l >= 'A' && l <= 'Z')
			l += 'a' - 'A';
		if (ret = f - l) break;
	}

	return ret;
}

char *strchr(const char *str, int chr)
{
	do
	{
		if (*str == (char)chr)
			goto suc;
	} while (*str++);
	str = 0;

suc:
	return (char *)str;
}

char *strstr(const char *str1, const char *str2)
{
	const char *pt1;
	const char *pt2;

	while (*str1)
	{
		pt1 = str1;
		pt2 = str2;
		do
		{
			if (!*pt2) goto suc;
		} while (*pt1++ == *pt2++);
		str1++;
	}
	str1 = 0;

suc:
	return (char *)str1;
}

char *strrchr(const char *string, int ch)
{
	const char *start;

	start = string;
	while (*string++);
	while (--string != start)
		if (*string == (char)ch)
			goto suc;
	string = 0;

suc:
	return (char *)string;
}

void srand(unsigned int seed)
{
	holdrand = (long)seed;
}

int rand(void)
{
	return(((holdrand = holdrand * 214013L + 2531011L) >> 16) & 0x7fff);
}

void replace(char *str, const char *s1, const char *s2)
{
	char *p1 = str, *p2;
	int n1 = strlen(s1);
	int n2 = strlen(s2);

	while ((p1 = strstr(p1, s1)) != NULL)
	{
		p2 = p1 + n1;
		memmove(p1 + n2, p2, strlen(p2));
		memcpy(p1, s2, n2);
		p1 = p2;
	}
}

int compare(const char *str1, const char *str2)
{
	UCHAR chr;

	while (*str1 && *str2)
	{
		switch (*str1)
		{
		case '*':
			while (*++str1 && *str1 == '*');
			do
			{
				chr = *str2;
				if (chr >= 'a' && chr <= 'z')
					chr -= 'a' - 'A';
			} while (*str1 != chr && *++str2);
			continue;
		case '?':
			str1++;
			str2++;
			continue;
		}
		chr = *str2;
		if (chr >= 'a' && chr <= 'z')
			chr -= 'a' - 'A';
		if (*str1 != chr)
			break;
		str1++;
		str2++;
	}

	return *str2 - *str1;
}