unibase.h

数字签名的例子

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Uniform Base Library
// Version 1.0.5
#pragma once

//#define _LOGMSG
//#define _LOGCON
//#define _LOGFILE

#define _WINSTR
#ifndef WINCE
#define _SHLSTR
#endif

#if defined(_UNICODE) && !defined(UNICODE)
#define UNICODE
#endif

#define _CRT_SECURE_NO_DEPRECATE
#define _CRT_NON_CONFORMING_SWPRINTFS

#include <TChar.h>
#include <StdIO.h>
#include <StdLib.h>
#include <String.h>
#include <Memory.h>
#include <Windows.h>
#include <ShLwApi.h>
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Type
#define VOID						void
typedef void						*PVOID;
typedef void						*HANDLE;
typedef HANDLE						*PHANDLE;
typedef int							BOOL, *PBOOL;
typedef float						FLOAT, *PFLOAT;
typedef double						DOUBLE, *PDOUBLE;

typedef int							INT, *PINT;
typedef signed char					INT8, *PINT8;
typedef signed short				INT16, *PINT16;
typedef signed int					INT32, *PINT32;
typedef signed __int64				INT64, *PINT64;

typedef unsigned int				UINT, *PUINT;
typedef unsigned char				UINT8, *PUINT8;
typedef unsigned short				UINT16, *PUINT16;
typedef unsigned int				UINT32, *PUINT32;
typedef unsigned __int64			UINT64, *PUINT64;

typedef unsigned char				BYTE, *PBYTE;
typedef unsigned short				WORD, *PWORD;
typedef unsigned long				DWORD, *PDWORD;
typedef unsigned __int64			QWORD, *PQWORD;

#ifndef _WCHAR_T_DEFINED
#define _WCHAR_T_DEFINED
typedef unsigned short				wchar_t;
#endif

typedef char						CHAR, *PCHAR;
typedef wchar_t						WCHAR, *PWCHAR;
#ifdef _UNICODE
typedef WCHAR						TCHAR, *PTCHAR;
#else
typedef CHAR						TCHAR, *PTCHAR;
#endif

typedef CHAR						*PSTR;
typedef WCHAR						*PWSTR;
typedef TCHAR						*PTSTR;
typedef const CHAR					*PCSTR;
typedef const WCHAR					*PCWSTR;
typedef const TCHAR					*PCTSTR;

typedef const VOID					*PCVOID;
typedef const BYTE					*PCBYTE;

#ifndef CONST
#define CONST						const
#endif

#ifndef STATIC
#define STATIC						static
#endif

#ifndef TEXT
#ifdef _UNICODE
#define TEXT(t)						L##t
#else
#define TEXT(t)						t
#endif
#endif
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Const
#ifndef TRUE
#define TRUE						1
#endif

#ifndef FALSE
#define FALSE						0
#endif

#ifndef NULL
#define NULL						0
#endif

#ifndef MAX_STR
#define MAX_STR						1024
#endif

#ifndef MAX_PATH
#define MAX_PATH					260
#endif

#ifndef MAX_NAME
#define MAX_NAME					80
#endif

#define UFILE_READ					GENERIC_READ
#define UFILE_WRITE					GENERIC_WRITE
#define UFILE_ALL					GENERIC_ALL
#define UFILE_APPEND				(GENERIC_READ | GENERIC_WRITE)

#define UFILE_BEGIN					FILE_BEGIN
#define UFILE_CURRENT				FILE_CURRENT
#define UFILE_END					FILE_END
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////




////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Define
#ifndef UCALL
#define UCALL						WINAPI
#endif

#ifndef UAPI
#define UAPI						__inline
#endif

typedef SYSTEMTIME					UTIME, *PUTIME;
typedef DWORD						(UCALL* UPROC)(PVOID pvParam);
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Macro
#define _NumOf(s)					(sizeof(s) / sizeof(s[0]))
#define _Zero(p)					UMemSet(p, 0, sizeof(*p))
#define _Max(a, b)					(((a) > (b)) ? (a) : (b))
#define _Min(a, b)					(((a) < (b)) ? (a) : (b))

#define _SafeFree(p)				if (p) {UMemFree(p); p = NULL;}
#define _SafeDelete(p)				if (p) {delete p; p = NULL;}
#define _SafeRelease(p)				if (p) {(p)->Release(); p = NULL;}

#define _RectWidth(r)				((r).right - (r).left)
#define _RectHeight(r)				((r).bottom - (r).top)

#define _LoadStr(i, t)				(LoadString(g_hInst, i, t, _NumOf(t)), t)
#define _GetStr(i)					_LoadStr(i, tzStr)

#define _IsIntRes(r)				((((DWORD) (r)) >> 16) == 0)
#define _MakeIntRes(i)				((PTSTR) ((DWORD) (i)))

#ifdef __cplusplus
template<typename T> VOID _Swap(T& t1, T& t2) {T t; t = t1; t1 = t2; t2 = t;}
#else
#define _Swap(t1, t2, T)			{T t; t = t1; t1 = t2; t2 = t;}
#endif
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// String
#ifdef _UNICODE

#define UStrLen						UWStrLen
#define UStrCopy					UWStrCopy
#define UStrCopyN					UWStrCopyN
#define UStrCat						UWStrCat
#define UStrCmp						UWStrCmp
#define UStrCmpI					UWStrCmpI
#define UStrCmpN					UWStrCmpN
#define UStrCmpNI					UWStrCmpNI

#define UStrChr						UWStrChr
#define UStrRChr					UWStrRChr
#define UStrStr						UWStrStr
#define UStrStrI					UWStrStrI

#define UStrRep						UWStrRep
#define UStrTrim					UWStrTrim
#define UStrToUpper					UWStrToUpper
#define UStrToLower					UWStrToLower
#define UStrToInt					UWStrToInt
#define UStrFromInt					UWStrFromInt
#define UStrPrint					UWStrPrint
#define UStrPrintV					UWStrPrintV

#define UStrToAStr(s, t, n)			UWStrToAStr(s, t, n)
#define UStrToWStr(w, t, n)			UWStrCopyN(w, t, n)
#define UAStrToStr(t, s, n)			UAStrToWStr(t, s, n)
#define UWStrToStr(t, w, n)			UWStrCopyN(t, w, n)

#else

#define UStrLen						UAStrLen
#define UStrCopy					UAStrCopy
#define UStrCopyN					UAStrCopyN
#define UStrCat						UAStrCat
#define UStrCmp						UAStrCmp
#define UStrCmpI					UAStrCmpI
#define UStrCmpN					UAStrCmpN
#define UStrCmpNI					UAStrCmpNI

#define UStrChr						UAStrChr
#define UStrRChr					UAStrRChr
#define UStrStr						UAStrStr
#define UStrStrI					UAStrStrI

#define UStrRep						UAStrRep
#define UStrTrim					UAStrTrim
#define UStrToUpper					UAStrToUpper
#define UStrToLower					UAStrToLower
#define UStrToInt					UAStrToInt
#define UStrFromInt					UAStrFromInt
#define UStrPrint					UAStrPrint
#define UStrPrintV					UAStrPrintV

#define UStrToAStr(s, t, n)			UAStrCopyN(s, t, n)
#define UStrToWStr(w, t, n)			UAStrToWStr(w, t, n)
#define UAStrToStr(t, s, n)			UAStrCopyN(t, s, n)
#define UWStrToStr(t, w, n)			UWStrToAStr(t, w, n)

#endif
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Memory
UAPI PVOID UMemAlloc(UINT uSize)
{
	return malloc(uSize);
}

UAPI PVOID UMemRealloc(PVOID pvMem, UINT uSize)
{
	return realloc(pvMem, uSize);
}

UAPI VOID UMemFree(PVOID pvMem)
{
	free(pvMem);
}

UAPI PVOID UMemSet(PVOID pvMem, CHAR cVal, UINT uSize)
{
	return memset(pvMem, cVal, uSize);
}

UAPI PVOID UMemCopy(PVOID pvDst, PCVOID pvSrc, UINT uSize)
{
	return memcpy(pvDst, pvSrc, uSize);
}

UAPI PVOID UMemMove(PVOID pvDst, PCVOID pvSrc, UINT uSize)
{
	return memmove(pvDst, pvSrc, uSize);
}

UAPI INT UMemCmp(PCVOID pvMem1, PCVOID pvMem2, UINT uSize)
{
	return memcmp(pvMem1, pvMem2, uSize);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Transformable string
UAPI PWSTR UAStrToWStr(PWSTR pwzDst, PCSTR pszSrc, UINT uLen)
{
	MultiByteToWideChar(CP_ACP, 0, pszSrc, -1, pwzDst, uLen);
	return pwzDst;
}

UAPI PSTR UWStrToAStr(PSTR pszDst, PCWSTR pwzSrc, UINT uLen)
{
	WideCharToMultiByte(CP_ACP, 0,pwzSrc, -1, pszDst, uLen, NULL, NULL);
	return pszDst;
}

UAPI BOOL UChrIsNum(TCHAR c)
{
	return (c >= '0') && (c <= '9');
}

UAPI BOOL UChrIsAlpha(TCHAR c)
{
	return (c >= 'A') && (c <= 'Z') || (c >= 'a') && (c <= 'z');
}

UAPI TCHAR UChrToLower(TCHAR c)
{
	return ((c >= 'A') && (c <= 'Z')) ? (c - 'A' + 'a') : c;
}

UAPI TCHAR UChrToUpper(TCHAR c)
{
	return ((c >= 'a') && (c <= 'z')) ? (c + 'A' - 'a') : c;
}

UAPI TCHAR UChrEqual(TCHAR c1, TCHAR c2)
{
	return ((c1 == c2) || (c1 == c2 - 'A' + 'a') || (c1 == c2 + 'A' - 'a'));
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// ANSI string*/
UAPI UINT UAStrLen(PCSTR pszStr)
{
#ifdef _WINSTR
	return (UINT) lstrlenA(pszStr);
#else
	return (UINT) strlen(pszStr);
#endif
}

UAPI PSTR UAStrCopy(PSTR pszDst, PCSTR pszSrc)
{
#ifdef _WINSTR
	return lstrcpyA(pszDst, pszSrc);
#else
	return strcpy(pszDst, pszSrc);
#endif
}

UAPI PSTR UAStrCopyN(PSTR pszDst, PCSTR pszSrc, UINT uLen)
{
#ifdef _SHLSTR
	return StrCpyNA(pszDst, pszSrc, uLen);
#else
	pszDst[--uLen] = 0;
	return strncpy(pszDst, pszSrc, uLen);
#endif
}

UAPI PSTR UAStrCat(PSTR pszDst, PCSTR pszSrc)
{
#ifdef _WINSTR
	return lstrcatA(pszDst, pszSrc);
#else
	return strcat(pszDst, pszSrc);
#endif
}

UAPI INT UAStrCmp(PCSTR pszStr1, PCSTR pszStr2)
{
#ifdef _WINSTR
	return lstrcmpA(pszStr1, pszStr2);
#else
	return strcmp(pszStr1, pszStr2);
#endif
}

UAPI INT UAStrCmpI(PCSTR pszStr1, PCSTR pszStr2)
{
#ifdef _WINSTR
	return lstrcmpiA(pszStr1, pszStr2);
#else
	return _stricmp(pszStr1, pszStr2);
#endif
}

UAPI INT UAStrCmpN(PCSTR pszStr1, PCSTR pszStr2, UINT uLen)
{
#ifdef _SHLSTR
	return StrCmpNA(pszStr1, pszStr2, uLen);
#else
	return strncmp(pszStr1, pszStr2, uLen);
#endif
}

UAPI INT UAStrCmpNI(PCSTR pszStr1, PCSTR pszStr2, UINT uLen)
{
#ifdef _SHLSTR
	return StrCmpNIA(pszStr1, pszStr2, uLen);
#else
	return _strnicmp(pszStr1, pszStr2, uLen);
#endif
}

UAPI PSTR UAStrChr(PCSTR pszStr, CHAR cChr)
{
#ifdef _SHLSTR
	return (PSTR) StrChrA(pszStr, cChr);
#else
	return (PSTR) strchr(pszStr, cChr);
#endif
}

UAPI PSTR UAStrRChr(PCSTR pszStr, CHAR cChr)
{
#ifdef _SHLSTR
	return (PSTR) StrRChrA(pszStr, NULL, cChr);
#else
	return (PSTR) strrchr(pszStr, cChr);
#endif
}

UAPI PSTR UAStrStr(PCSTR pszStr1, PCSTR pszStr2)
{
#ifdef _SHLSTR
	return (PSTR) StrStrA(pszStr1, pszStr2);
#else
	return (PSTR) strstr(pszStr1, pszStr2);
#endif
}

UAPI PSTR UAStrStrI(PCSTR pszStr1, PCSTR pszStr2)
{
#ifdef _SHLSTR
	return StrStrIA(pszStr1, pszStr2);
#else
	PSTR p = (PSTR) pszStr1;
	while (*p)
	{
		PSTR s1 = p;
		PSTR s2 = (PSTR) pszStr2;

		while (*s1 && *s2 && UChrEqual(*s1, *s2))
		{
			s1++;
			s2++;
		}

		if (*s2 == 0)
		{
			return p;
		}

		p++;
	}
	return NULL;
#endif
}

UAPI PSTR UAStrRep(PSTR ptzStr, CHAR cFind, CHAR cRep)
{
	PSTR p = ptzStr;
	for (; *p; p++)
	{
		if (*p == cFind)
		{
			*p = cRep;
		}
	}
	return ptzStr;
}

UAPI PSTR UAStrTrim(PSTR ptzStr, CHAR cTrim)
{
	if (*ptzStr == cTrim)
	{
		PSTR p = ptzStr + UAStrLen(ptzStr) - 1;
		if (*p == cTrim)
		{
			*p = 0;
		}
		return ptzStr + 1;
	}
	return ptzStr;
}

UAPI PSTR UAStrToUpper(PSTR pzStr)
{
#ifdef _WINSTR
	return CharUpperA(pzStr);
#else
	return _strupr(pzStr);
#endif
}

UAPI PSTR UAStrToLower(PSTR pzStr)
{
#ifdef _WINSTR
	return CharLowerA(pzStr);
#else
	return _strlwr(pzStr);
#endif
}

UAPI INT UAStrToInt(PCSTR pszStr)
{
#ifdef _SHLSTR
	INT i = 0;
	StrToIntExA(pszStr, STIF_SUPPORT_HEX, &i);
	return i;
#else
	return atoi(pszStr);
#endif
}

UAPI PSTR UAStrFromInt(PSTR pszDst, INT iVal)
{
#ifdef _WINSTR
	wsprintfA(pszDst, "%d", iVal);
	return pszDst;
#else
	return _itoa(iVal, pszDst, 10);
#endif
}

#ifdef _WINSTR
#define UAStrPrint wsprintfA
#define UAStrPrintV wvsprintfA
#else
#define UAStrPrint sprintf
#define UAStrPrintV vsprintf
#endif
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Wide string
UAPI UINT UWStrLen(PCWSTR pwzStr)
{
#ifdef _WINSTR
	return (UINT) lstrlenW(pwzStr);
#else
	return (UINT) wcslen(pwzStr);
#endif
}

UAPI PWSTR UWStrCopy(PWSTR pwzDst, PCWSTR pwzSrc)
{
#ifdef _WINSTR
	return lstrcpyW(pwzDst, pwzSrc);
#else
	return wcscpy(pwzDst, pwzSrc);
#endif
}

UAPI PWSTR UWStrCopyN(PWSTR pwzDst, PCWSTR pwzSrc, UINT uLen)
{
#ifdef _SHLSTR
	return StrCpyNW(pwzDst, pwzSrc, uLen);
#else
	pwzDst[--uLen] = 0;