www.pudn.com > ntshell.rar > shlib.c

#include  
#include  
 
#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; 
}