1748 lines
64 KiB
C++
1748 lines
64 KiB
C++
|
|
|
|
#ifndef __ZCPPMAIN__ZMAINENC_H__
|
|
#define __ZCPPMAIN__ZMAINENC_H__
|
|
|
|
|
|
#include "ZCppMain/ZMainHead.H"
|
|
|
|
|
|
namespace ZNsMain
|
|
{
|
|
|
|
namespace ZNsEnc
|
|
{
|
|
|
|
template<typename TTypInt> char ZftGetHexOfChar(TTypInt AI_IntVal)
|
|
{
|
|
// must be AI_IntVal>=0 || AI_IntVal<16
|
|
|
|
if(AI_IntVal<10)
|
|
return '0'+AI_IntVal;
|
|
else return 'A'+(AI_IntVal-10);
|
|
}/*
|
|
template<typename TTypInt> char ZftGetHexOfChar(TTypInt AI_IntVal) */
|
|
|
|
inline char ZfGetCharOfHex(char AC_HexChar)
|
|
{
|
|
if(AC_HexChar>='0' && AC_HexChar<='9') return AC_HexChar-'0' ;
|
|
if(AC_HexChar>='A' && AC_HexChar<='Z') return AC_HexChar-'A'+10;
|
|
if(AC_HexChar>='a' && AC_HexChar<='z') return AC_HexChar-'a'+10;
|
|
|
|
return 0; // 이 부분이 수행되게 해서는 안된다.
|
|
}/*
|
|
inline char ZfGetCharOfHex(char AC_HexChar)*/
|
|
|
|
inline ZTypUChar ZfGetUCharOfHex(ZTypUChar AUC_HexChar)
|
|
{
|
|
if(AUC_HexChar>='0' && AUC_HexChar<='9') return AUC_HexChar-'0' ;
|
|
if(AUC_HexChar>='A' && AUC_HexChar<='Z') return AUC_HexChar-'A'+10;
|
|
if(AUC_HexChar>='a' && AUC_HexChar<='z') return AUC_HexChar-'a'+10;
|
|
|
|
return 0; // 이 부분이 수행되게 해서는 안된다.
|
|
}/*
|
|
inline ZTypUChar ZfGetUCharOfHex(ZTypUChar AUC_HexChar)*/
|
|
|
|
|
|
template<typename TString> TString& ZftGetUrlEnc
|
|
(const char* APC_Origin, long AL_Length, TString& ARR_CStringEnc)
|
|
{
|
|
typedef unsigned char ZTypUChar;
|
|
|
|
if(AL_Length<0)
|
|
{
|
|
ARR_CStringEnc.Invalidate(0); return ARR_CStringEnc;
|
|
}
|
|
/*///////////*/
|
|
|
|
char *VPC_Encode, VCA_Buff[2+1];
|
|
ZTypUChar c=0; int i=0, j=0 ;
|
|
|
|
ARR_CStringEnc.ReAlloc(AL_Length*3+1) ;
|
|
ARR_CStringEnc.Invalidate(0) ;
|
|
VPC_Encode = (char*)ARR_CStringEnc ;
|
|
|
|
if(APC_Origin==0 || VPC_Encode==0)
|
|
return ARR_CStringEnc;
|
|
/*++++++++++++++++++++++++++++++*/
|
|
|
|
for(i = j = 0; APC_Origin[i]; i++)
|
|
{
|
|
c = (ZTypUChar)APC_Origin[i];
|
|
|
|
/*///////////////////////////////////////////////////////////
|
|
|
|
qDecoder 라이브러리에 있던 코드
|
|
'\\' 문자를 encode 하지 않으므로 약간 바꾼다.
|
|
|
|
if((c >= '0') && (c <= '9')) VPC_Encode[j++] = c;
|
|
else if((c >= 'A') && (c <= 'Z')) VPC_Encode[j++] = c;
|
|
else if((c >= 'a') && (c <= 'z')) VPC_Encode[j++] = c;
|
|
else if((c == '@') || (c == '.') || (c == '/') || (c == '\\')
|
|
|| (c == '-') || (c == '_') || (c == ':') )
|
|
VPC_Encode[j++] = c;
|
|
else
|
|
{
|
|
sprintf(VCA_Buff, "%02x", c);
|
|
VPC_Encode[j++] = '%';
|
|
VPC_Encode[j++] = VCA_Buff[0];
|
|
VPC_Encode[j++] = VCA_Buff[1];
|
|
}
|
|
//else
|
|
|
|
///////////////////////////////////////////////////////////*/
|
|
|
|
if ((c >= '0') && (c <= '9')) VPC_Encode[j++] = c;
|
|
else if((c >= 'A') && (c <= 'Z')) VPC_Encode[j++] = c;
|
|
else if((c >= 'a') && (c <= 'z')) VPC_Encode[j++] = c;
|
|
else if((c == '@') || (c == '.') || (c == '/')
|
|
|| (c == '-') || (c == '_') || (c == ':') )
|
|
VPC_Encode[j++] = c;
|
|
else if(c == '\\')
|
|
{
|
|
VPC_Encode[j++] = '%';
|
|
VPC_Encode[j++] = '5';
|
|
VPC_Encode[j++] = 'c';
|
|
|
|
// VPC_Encode[j++] = 'C'; 라 해도
|
|
// URL 디코딩한 결과는 같다.
|
|
}
|
|
else
|
|
{
|
|
::sprintf(VCA_Buff, "%02x", c);
|
|
|
|
VPC_Encode[j++] = '%' ;
|
|
VPC_Encode[j++] = VCA_Buff[0] ;
|
|
VPC_Encode[j++] = VCA_Buff[1] ;
|
|
}/*
|
|
else*/
|
|
}/*
|
|
for(i = j = 0; APC_Origin[i]; i++) */
|
|
|
|
VPC_Encode[j]='\0'; ARR_CStringEnc.CorrectLength(j-1); return ARR_CStringEnc;
|
|
}/*
|
|
template<typename TString> TString& ZftGetUrlEnc
|
|
(const char* APC_Origin, long AL_Length, TString& ARR_CStringEnc) */
|
|
|
|
template<typename TString> TString& ZftGetUrlEnc(const char* APC_Origin, TString& ARR_CStringEnc)
|
|
{
|
|
return ZftGetUrlEnc(APC_Origin, ZNsMain::ZftLength(APC_Origin), RR(ARR_CStringEnc));
|
|
}/*
|
|
template<typename TString> TString& ZftGetUrlEnc(const char* APC_Origin, TString& ARR_CStringEnc) */
|
|
|
|
template<typename TString> TString& ZftGetUrlEnc(TString& ARR_CStringData)
|
|
{
|
|
// ARR_CStringEnc 이 원본 문자열이며 이 문자열을
|
|
// 인코딩한 것은 ARR_CStringEnc 에 또 전달한다.
|
|
|
|
TString VO_CStringEnc; ZftGetUrlEnc
|
|
(
|
|
ARR_CStringData.data(),
|
|
ARR_CStringData.size(),
|
|
RR(VO_CStringEnc)
|
|
);
|
|
///////////////////////////////////
|
|
|
|
return ARR_CStringData = VO_CStringEnc;
|
|
}/*
|
|
template<typename TString> TString& ZftGetUrlEnc(CString& ARR_CStringData) */
|
|
|
|
|
|
template<typename TypeChar> TypeChar* ZftGetUrlDec(TypeChar* APC_Origin, long& ARRL_Length)
|
|
{
|
|
|
|
class ZCHelpHex
|
|
{
|
|
public:
|
|
|
|
static inline TypeChar ZftGetHexOfChar(TypeChar AC_HexUp, TypeChar AC_HexLow)
|
|
{
|
|
char VC_Digit = 0;
|
|
|
|
VC_Digit = 16 * (AC_HexUp >= 'A' ? ((AC_HexUp & 0xdf) - 'A') + 10 : (AC_HexUp - '0'));
|
|
VC_Digit += (AC_HexLow >= 'A' ? ((AC_HexLow & 0xdf) - 'A') + 10 : (AC_HexLow - '0'));
|
|
|
|
return (VC_Digit);
|
|
}/*
|
|
static inline TypeChar ZftGetHexOfChar(TypeChar AC_HexUp, TypeChar AC_HexLow)*/
|
|
|
|
public:
|
|
};/*
|
|
class ZCHelpHex*/
|
|
|
|
|
|
if(ARRL_Length<1) return 0;
|
|
|
|
|
|
int i=0; int j=0;
|
|
|
|
for(i = j = 0; j<ARRL_Length; i++, j++)
|
|
{
|
|
switch(APC_Origin[j])
|
|
{
|
|
case '+':
|
|
{
|
|
APC_Origin[i] = ' '; break;
|
|
}
|
|
case '%':
|
|
{
|
|
APC_Origin[i] = ZCHelpHex::ZftGetHexOfChar
|
|
( APC_Origin[j + 1], APC_Origin[j + 2] );
|
|
|
|
j += 2; break;
|
|
}
|
|
default:
|
|
{
|
|
APC_Origin[i] = APC_Origin[j]; break;
|
|
}/*
|
|
default:*/
|
|
}/*
|
|
switch(APC_Origin[j])*/
|
|
}/*
|
|
for(i = j = 0; j<ARRL_Length; i++, j++) */
|
|
|
|
APC_Origin[ARRL_Length=i]='\0'; return APC_Origin;
|
|
}/*
|
|
template<typename TypeChar> TypeChar* ZftGetUrlDec(TypeChar* APC_Origin, long& ARRL_Length) */
|
|
|
|
template<typename TString> TString& ZftGetUrlDec(TString& ARR_CStringDec)
|
|
{
|
|
long VL_DecSize=ARR_CStringDec.size();
|
|
|
|
ZftGetUrlDec(ARR_CStringDec.c_str(), RR(VL_DecSize));
|
|
|
|
ARR_CStringDec.Invalid(VL_DecSize); return ARR_CStringDec;
|
|
}/*
|
|
template<typename TString> TString& ZftGetUrlDec(TString& ARR_CStringDec) */
|
|
|
|
template<typename TString> TString& ZftGetUrlUCS2Enc
|
|
(const char* APC_Origin, long AL_Length, TString& ARR_CStringEnc)
|
|
{
|
|
/*///////////////////////////////////////////////////////////////////////////
|
|
|
|
■ APC_Origin 을 UCS2 UNICODE 라 했을 때, 2 바이트씩 끊어서
|
|
"%u" 로 시작하는 URL 포맷으로 바꾼다. 그래서 javascript 의 escape() 함수가
|
|
이 형식의 값을 반환한다. 닷넷 사이트에서 주로 이 형식으로 검색어를 사용한
|
|
다.
|
|
|
|
■ Window 에서 문자셋 CP949 를 이 함수에서 인식하는 UCS2 UNICODE 로 바꾸려면
|
|
우선 iconv 라이브러리로 "CP949" 문자열을 "UCS-2" 로 바꾸어주고 이 문자열
|
|
을 2 바이트씩 host byte 로 변환시켜주어야 한다.
|
|
|
|
-- 2008-12-05 01:55:00
|
|
|
|
※ Window 에서는 iconv 라이브러리로 "CP949" 문자열을 "UTF-16LE" 로 바꾸어
|
|
주면 된다.
|
|
|
|
-- 2009-01-08 23:23:00
|
|
|
|
■ 2 바이트가 6 바이트로 표현되니까 길이가 3 배 늘어나다.
|
|
|
|
■ 유니코드(UTF16) <--> UTF8
|
|
|
|
int WideCharToMultiByte
|
|
(
|
|
UINT CodePage , // code page
|
|
DWORD dwFlags , // performance and mapping flags
|
|
LPCWSTR lpWideCharStr , // wide-character string
|
|
int cchWideChar , // number of chars in string
|
|
LPSTR lpMultiByteStr, // buffer for new string
|
|
int cbMultiByte , // size of buffer
|
|
LPCSTR lpDefaultChar , // default for unmappable chars
|
|
LPBOOL lpUsedDefaultChar // set when default char used
|
|
);
|
|
|
|
이 함수의 첫번째 매개변수 CodePage에 CP_UTF8를 할당하여 사용합니다
|
|
|
|
IN http://blog.naver.com/zetman99?Redirect=Log&logNo=110027694397
|
|
|
|
-- 2009-01-08 15:38:00
|
|
|
|
///////////////////////////////////////////////////////////////////////////*/
|
|
|
|
long VL_Count = AL_Length/2 ;
|
|
|
|
if(VL_Count<1) return ARR_CStringEnc;
|
|
|
|
|
|
using ZNsMain::ZNsEnc::ZftGetHexOfChar ;
|
|
|
|
ARR_CStringEnc.resize(VL_Count*6, ' '); // UCS2 문자 하나가 6 바이트로 표현된다.
|
|
|
|
char* VPC_Enc = ARR_CStringEnc.data() ;
|
|
::uint16_t* VPUI_UCS2= (::uint16_t*)APC_Origin;
|
|
::uint16_t VUI_Temp = 0 ;
|
|
|
|
for(long i=0; i<VL_Count; ++i)
|
|
{
|
|
VUI_Temp = *VPUI_UCS2++ ;
|
|
|
|
/* 아래 (::uint16_t) 을 명시적으로 사용했음에 주의.
|
|
이 코드가 없으면 VUI_Temp 의 Shift 연산 결과가
|
|
::uint16_t 형이 아니고 int 형으로 되버리니까, 이
|
|
상태에서 다시 >>12 을 수행하면 원래 값과 같아져 버린다!
|
|
*/
|
|
*VPC_Enc++ = '%';
|
|
*VPC_Enc++ = 'u';
|
|
*VPC_Enc++ = ZftGetHexOfChar((::uint16_t) VUI_Temp >>12);
|
|
*VPC_Enc++ = ZftGetHexOfChar((::uint16_t)(VUI_Temp<<4 )>>12);
|
|
*VPC_Enc++ = ZftGetHexOfChar((::uint16_t)(VUI_Temp<<8 )>>12);
|
|
*VPC_Enc++ = ZftGetHexOfChar((::uint16_t)(VUI_Temp<<12)>>12);
|
|
}/*
|
|
for(long i=0; i<VL_Count; ++i)*/
|
|
|
|
return ARR_CStringEnc;
|
|
}/*
|
|
template<typename TString> TString& ZftGetUrlUCS2Enc
|
|
(const char* APC_Origin, long AL_Length, TString& ARR_CStringEnc) */
|
|
|
|
template<typename TypeChar> TypeChar*
|
|
ZftGetUrlUCS2Dec(TypeChar* APC_Origin, long& ARRL_Length)
|
|
{
|
|
long VL_Count=ARRL_Length/6;
|
|
|
|
if(VL_Count<1) return APC_Origin;
|
|
|
|
using ZNsMain::ZNsEnc::ZfGetCharOfHex ;
|
|
|
|
char* VPC_Enc = APC_Origin ;
|
|
::uint16_t* VPUI_UCS2= (::uint16_t*)APC_Origin;
|
|
::uint16_t VUI_Temp = 0 ;
|
|
|
|
for(long i=0; i<VL_Count; ++i)
|
|
{
|
|
VPC_Enc+=2; // "%u" 를 건너뛴다.
|
|
|
|
VUI_Temp += ::uint16_t(ZfGetCharOfHex(*VPC_Enc++))*16*16*16;
|
|
VUI_Temp += ::uint16_t(ZfGetCharOfHex(*VPC_Enc++))*16*16 ;
|
|
VUI_Temp += ::uint16_t(ZfGetCharOfHex(*VPC_Enc++))*16 ;
|
|
VUI_Temp += ::uint16_t(ZfGetCharOfHex(*VPC_Enc++)) ;
|
|
|
|
*VPUI_UCS2++=VUI_Temp; VUI_Temp=0;
|
|
}/*
|
|
for(long i=0; i<VL_Count; ++i)*/
|
|
|
|
ARRL_Length=VL_Count*2; return APC_Origin;
|
|
}/*
|
|
template<typename TypeChar> TypeChar*
|
|
ZftGetUrlUCS2Dec(TypeChar* APC_Origin, long& ARRL_Length) */
|
|
|
|
template<typename TString> TString& ZftGetUrlUCS2Dec(TString& ARR_CStringDec)
|
|
{
|
|
long VL_Length = ARR_CStringDec.size() ;
|
|
ZftGetUrlUCS2Dec
|
|
( ARR_CStringDec.data(), RR(VL_Length) );
|
|
|
|
ARR_CStringDec.resize(VL_Length,' ') ;
|
|
|
|
return ARR_CStringDec;
|
|
}/*
|
|
template<typename TString> TString& ZftGetUrlUCS2Dec(TString& ARR_CStringDec) */
|
|
|
|
|
|
template<typename TypeChar> const TypeChar* ZftGetBase64Table()
|
|
{
|
|
const TypeChar* CPC_Base64Table =
|
|
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
|
|
|
return CPC_Base64Table;
|
|
}/*
|
|
template<typename TypeChar> const TypeChar* ZftGetBase64Table()*/
|
|
|
|
template<typename TString> char* ZftGetBase64Enc(
|
|
const unsigned char *APC_Origin, long AL_Length,TString& ARR_CStringEnc)
|
|
{
|
|
// APC_Origin 을 base64 로 인코딩해서 ARR_CStringEnc 에 덧붙인다.
|
|
|
|
typedef unsigned char ZTypUChar;
|
|
|
|
ZTypUChar *VPC_Out, *VPC_Pos;
|
|
const ZTypUChar *VPC_End, *VCA_In ;
|
|
|
|
long VL_OutLen, VL_LineLen, VL_PrevSize = ARR_CStringEnc.size();
|
|
|
|
VL_OutLen = AL_Length * 4 / 3 + 4; // 3-byte blocks to 4-byte
|
|
VL_OutLen += VL_OutLen / 72 ; // line feeds
|
|
|
|
ARR_CStringEnc.resize(VL_PrevSize+VL_OutLen,' ');
|
|
|
|
VPC_Out = (ZTypUChar*)(ARR_CStringEnc.c_str()+VL_PrevSize);
|
|
|
|
if(VPC_Out == NULL)
|
|
{
|
|
ARR_CStringEnc.resize(VL_PrevSize); return NULL;
|
|
}/*
|
|
if(VPC_Out == NULL)*/
|
|
|
|
VPC_End = APC_Origin + AL_Length;
|
|
VCA_In = APC_Origin ;
|
|
VPC_Pos = VPC_Out ;
|
|
VL_LineLen= 0 ;
|
|
|
|
const ZTypUChar* CPC_Base64Table = (ZTypUChar*)ZftGetBase64Table<char>();
|
|
|
|
while(VPC_End-VCA_In>=3)
|
|
{
|
|
*VPC_Pos++ = CPC_Base64Table[VCA_In[0] >> 2];
|
|
*VPC_Pos++ = CPC_Base64Table[((VCA_In[0] & 0x03) << 4) | (VCA_In[1] >> 4)];
|
|
*VPC_Pos++ = CPC_Base64Table[((VCA_In[1] & 0x0f) << 2) | (VCA_In[2] >> 6)];
|
|
*VPC_Pos++ = CPC_Base64Table[VCA_In[2] & 0x3f];
|
|
VCA_In += 3; VL_LineLen += 4;
|
|
|
|
const int CI_LineUnit=72;
|
|
|
|
if(VL_LineLen>=CI_LineUnit)
|
|
{
|
|
*VPC_Pos++ = '\n'; VL_LineLen = 0;
|
|
}
|
|
/*///////////////////////*/
|
|
}/*
|
|
while(VPC_End-VCA_In>=3)*/
|
|
|
|
if(VPC_End-VCA_In)
|
|
{
|
|
*VPC_Pos++ = CPC_Base64Table[VCA_In[0] >> 2];
|
|
if (VPC_End - VCA_In == 1)
|
|
{
|
|
*VPC_Pos++ = CPC_Base64Table[(VCA_In[0] & 0x03) << 4];
|
|
*VPC_Pos++ = '=';
|
|
}
|
|
else
|
|
{
|
|
*VPC_Pos++ = CPC_Base64Table[((VCA_In[0] & 0x03) << 4) |
|
|
(VCA_In[1] >> 4)];
|
|
*VPC_Pos++ = CPC_Base64Table[(VCA_In[1] & 0x0f) << 2];
|
|
}/*
|
|
else*/
|
|
|
|
*VPC_Pos++ = '=';
|
|
VL_LineLen += 4 ;
|
|
}/*
|
|
if(VPC_End-VCA_In)*/
|
|
|
|
/* if(VL_LineLen>0) *VPC_Pos++ = '\n'; */
|
|
|
|
ARR_CStringEnc.
|
|
resize(VL_PrevSize+(VPC_Pos-VPC_Out), '=');
|
|
|
|
return (char*)VPC_Out;
|
|
}/*
|
|
template<typename TString> char* ZftGetBase64Enc
|
|
(const unsigned char *APC_Origin, long AL_Length, TString& ARR_CStringEnc) */
|
|
|
|
template<typename TString> char* ZftGetBase64Enc
|
|
(const char* APC_Origin, long AL_Length, TString& ARR_CStringEnc)
|
|
{
|
|
return ZftGetBase64Enc
|
|
((const unsigned char*)APC_Origin, AL_Length, RR(ARR_CStringEnc));
|
|
}/*
|
|
template<typename TString> char* ZftGetBase64Enc
|
|
(const char* APC_Origin, long AL_Length, TString& ARR_CStringEnc) */
|
|
|
|
template<typename TString> char* ZftGetBase64Enc
|
|
(const TString& ARR_CStringOri, TString& ARR_CStringEnc)
|
|
{
|
|
return ZftGetBase64Enc
|
|
(ARR_CStringOri.data(), ARR_CStringOri.size(), RR(ARR_CStringEnc));
|
|
}/*
|
|
template<typename TString> char* ZftGetBase64Enc
|
|
(const TString& ARR_CStringOri, TString& ARR_CStringEnc) */
|
|
|
|
template<typename TString> char* ZftGetBase64Dec
|
|
(const unsigned char* APC_Origin, long AL_Length,TString& ARR_CStringDec)
|
|
{
|
|
typedef unsigned char ZTypUChar;
|
|
|
|
ZTypUChar
|
|
VCA_TableBuff[256], *VPC_Out ,
|
|
*VPC_Pos , VCA_In[4] ,
|
|
VCA_Block[4] , VC_Temp ;
|
|
|
|
long i, VL_Count;
|
|
|
|
const int CI_Base64TableSize= 64;
|
|
const ZTypUChar* CPC_Base64Table =
|
|
(const ZTypUChar*)ZftGetBase64Table<char>() ;
|
|
|
|
memset(VCA_TableBuff, 0x80, 256);
|
|
|
|
for (i = 0; i < CI_Base64TableSize; i++)
|
|
{ VCA_TableBuff[CPC_Base64Table[i]] = i; }
|
|
|
|
VCA_TableBuff['=']=0; VL_Count=0; // '=' 는 61
|
|
|
|
for (i=0; i<AL_Length; i++)
|
|
{
|
|
if (VCA_TableBuff[APC_Origin[i]] != 0x80) VL_Count++;
|
|
}
|
|
/*///////////////////////*/
|
|
|
|
if (VL_Count % 4) return NULL;
|
|
|
|
|
|
ARR_CStringDec.resize(VL_Count,' ');
|
|
|
|
VPC_Pos = VPC_Out = (ZTypUChar*)ARR_CStringDec.c_str();
|
|
|
|
if (VPC_Out == NULL) return NULL;
|
|
|
|
|
|
VL_Count = 0;
|
|
|
|
for (i = 0; i < AL_Length; i++)
|
|
{
|
|
VC_Temp = VCA_TableBuff[APC_Origin[i]];
|
|
|
|
if (VC_Temp == 0x80) continue;
|
|
|
|
VCA_In[VL_Count] = APC_Origin[i];
|
|
VCA_Block[VL_Count] = VC_Temp ; VL_Count++;
|
|
|
|
if(VL_Count==4)
|
|
{
|
|
*VPC_Pos++ = (VCA_Block[0] << 2) | (VCA_Block[1] >> 4);
|
|
*VPC_Pos++ = (VCA_Block[1] << 4) | (VCA_Block[2] >> 2);
|
|
*VPC_Pos++ = (VCA_Block[2] << 6) | VCA_Block[3];
|
|
VL_Count = 0;
|
|
}/*
|
|
if(VL_Count==4)*/
|
|
}/*
|
|
for (i = 0; i < AL_Length; i++) */
|
|
|
|
|
|
if (VPC_Pos > VPC_Out)
|
|
{
|
|
if (VCA_In[2] == '=') VPC_Pos -= 2 ;
|
|
else if (VCA_In[3] == '=') VPC_Pos-- ;
|
|
}/*
|
|
if (VPC_Pos > VPC_Out)*/
|
|
|
|
ARR_CStringDec.resize(VPC_Pos - VPC_Out,' '); return (char*)VPC_Out;
|
|
}/*
|
|
template<typename TString> char* ZftGetBase64Dec
|
|
(const unsigned char* APC_Origin, long AL_Length,TString& ARR_CStringDec) */
|
|
|
|
template<typename TString> char* ZftGetBase64Dec
|
|
(const char* APC_Origin, long AL_Length,TString& ARR_CStringDec)
|
|
{
|
|
return ZftGetBase64Dec
|
|
((const unsigned char*)APC_Origin, AL_Length, RR(ARR_CStringDec));
|
|
}/*
|
|
template<typename TString> char* ZftGetBase64Dec
|
|
(const char* APC_Origin, long AL_Length, TString& ARR_CStringDec) */
|
|
|
|
template<typename TString> char* ZftGetBase64Dec
|
|
(const TString& ARR_CStringOri, TString& ARR_CStringDec)
|
|
{
|
|
return ZftGetBase64Dec
|
|
(ARR_CStringOri.data(), ARR_CStringOri.size(), RR(ARR_CStringDec));
|
|
}/*
|
|
template<typename TString> char* ZftGetBase64Dec
|
|
(const TString& ARR_CStringOri, TString& ARR_CStringDec) */
|
|
|
|
|
|
/*///////////////////////////////////////////////////////////////////////////////
|
|
|
|
■ 키이름과 키값의 쌍을 나타낼 때나 변수명과 변수값을 문자열로 표현할 때 Simple
|
|
Url(줄이면 SimUrl)라는 간단한 형식을 사용하자. 이 형식에서는 URL 형식과 비슷하
|
|
게 {변수명}={변수값} 의 쌍을 "&" 로 결합할 수 있도록, 데이타에 "&" 이 안들어가
|
|
게
|
|
|
|
'&' => %26
|
|
'%' => %25
|
|
'=' => %3D
|
|
|
|
으로 바꾸어 사용한다. 이 형식을 Simple URL 형식이라고 부르자.
|
|
|
|
■ -- 2009-05-22 18:05:00
|
|
|
|
///////////////////////////////////////////////////////////////////////////////*/
|
|
|
|
template<typename TString> TString& ZftGetSimUrlEnc
|
|
(const TString& AR_CStringOri, TString& ARR_CStringEnc)
|
|
{
|
|
if(&AR_CStringOri!=&ARR_CStringEnc)
|
|
{ ARR_CStringEnc = AR_CStringOri; }
|
|
|
|
ARR_CStringEnc.Replace("%","%25");
|
|
ARR_CStringEnc.Replace("=","%3D");
|
|
ARR_CStringEnc.Replace("&","%26");
|
|
|
|
return ARR_CStringEnc;
|
|
}/*
|
|
template<typename TString> TString& ZftGetSimUrlEnc
|
|
(const TString& AR_CStringOri, TString& ARR_CStringEnc) */
|
|
|
|
template<typename TString> TString& ZftGetSimUrlEnc(TString& ARR_CStringEnc)
|
|
{
|
|
ARR_CStringEnc.Replace("%","%25");
|
|
ARR_CStringEnc.Replace("=","%3D");
|
|
ARR_CStringEnc.Replace("&","%26");
|
|
|
|
return ARR_CStringEnc;
|
|
}/*
|
|
template<typename TString> TString& ZftGetSimUrlEnc(TString& ARR_CStringEnc) */
|
|
|
|
template<typename TString> TString& GetSimUrlDe
|
|
(const TString& AR_CStringOri, TString& ARR_CStringEnc)
|
|
{
|
|
ARR_CStringEnc=AR_CStringOri;
|
|
ARR_CStringEnc.Replace("%26","&");
|
|
ARR_CStringEnc.Replace("%3D","=");
|
|
ARR_CStringEnc.Replace("%25","%");
|
|
|
|
return ARR_CStringEnc;
|
|
}/*
|
|
template<typename TString> TString& ZftGetSimUrlDec
|
|
(const TString& AR_CStringOri, TString& ARR_CStringEnc) */
|
|
|
|
template<typename TString> TString& ZftGetSimUrlDec(TString& ARR_CStringOri)
|
|
{
|
|
ARR_CStringOri.Replace("%26","&");
|
|
ARR_CStringOri.Replace("%3D","=");
|
|
ARR_CStringOri.Replace("%25","%");
|
|
|
|
return ARR_CStringOri;
|
|
}/*
|
|
template<typename TString> TString& ZftGetSimUrlDec(TString& ARR_CStringOri) */
|
|
|
|
|
|
/*/////////////////////////////////////////////////////////////////////
|
|
|
|
■ 아주 간단한 암호화 복호화
|
|
|
|
1) 각 바이트 정수를 4 바이트의 문자열로 바꾼다.
|
|
2) 'A' 로 4 바이트 왼쪽 패딩한다.
|
|
3) 전체 문자열을 뒤집는다.
|
|
|
|
■ -- 2009-05-24 13:16:00
|
|
|
|
/////////////////////////////////////////////////////////////////////*/
|
|
|
|
template<typename TString> TString& ZftGetSimEnc
|
|
(const TString& AR_CStringOri, TString& ARR_CStringEnc)
|
|
{
|
|
typedef typename
|
|
TString::TypeChar TypeChar ;
|
|
|
|
const TypeChar* VP_Start
|
|
= AR_CStringOri.data() ;
|
|
|
|
TString VO_CStringBuff ;
|
|
|
|
for(int i=0;i<AR_CStringOri.size();++i)
|
|
{
|
|
VO_CStringBuff= int(*VP_Start++);
|
|
VO_CStringBuff.PadLeft(4, 'A' ); // 'A' 로 왼쪽 Padding
|
|
|
|
ARR_CStringEnc(VO_CStringBuff);
|
|
}/*
|
|
for(int i=0;i<AR_CStringOri.size();++i) */
|
|
|
|
return ARR_CStringEnc.Reverse();
|
|
}/*
|
|
template<typename TString> TString& ZftGetSimEnc
|
|
(const TString& AR_CStringOri, TString& ARR_CStringEnc) */
|
|
|
|
template<typename TString> TString& ZftGetSimDec
|
|
(const TString& AR_CStringOri, TString& ARR_CStringDec)
|
|
{
|
|
typedef typename TString::TypeChar TypeChar;
|
|
|
|
TString VO_CStringBuff ;
|
|
TString VO_CStringBuff4; // 4 바이트씩 자른 문자열 버퍼
|
|
|
|
VO_CStringBuff=AR_CStringOri;
|
|
VO_CStringBuff.Reverse() ;
|
|
|
|
TypeChar* VP_Start=VO_CStringBuff.data();
|
|
|
|
int VI_LoopCnt=VO_CStringBuff.size()/4;
|
|
|
|
for(int i=0; i<VI_LoopCnt; ++i)
|
|
{
|
|
(VO_CStringBuff4="")(VP_Start, 4); VP_Start+=4;
|
|
VO_CStringBuff4.Replace("A", "") ;
|
|
|
|
ARR_CStringDec(char(VO_CStringBuff4.GetInt()));
|
|
}/*
|
|
for(int i=0; i<AR_CStringOri.size(); ++i)*/
|
|
|
|
return ARR_CStringDec;
|
|
}/*
|
|
template<typename TString> TString& ZftGetSimDec
|
|
(const TString& AR_CStringOri, TString& ARR_CStringDec) */
|
|
|
|
|
|
static int ZfGetIntOfHex(char AC_Hex)
|
|
{
|
|
switch(AC_Hex)
|
|
{
|
|
case '0' : case '1' :
|
|
case '2' : case '3' :
|
|
case '4' : case '5' :
|
|
case '6' : case '7' :
|
|
case '8' : case '9' : return AC_Hex-'0';
|
|
|
|
case 'a' : case 'A' : return 10;
|
|
case 'b' : case 'B' : return 11;
|
|
case 'c' : case 'C' : return 12;
|
|
case 'd' : case 'D' : return 13;
|
|
case 'e' : case 'E' : return 14;
|
|
case 'f' : case 'F' : return 15;
|
|
};/*
|
|
switch(AC_Hex)*/
|
|
|
|
return -1;
|
|
}/*
|
|
static int ZfGetIntOfHex(char AC_Hex)*/
|
|
|
|
inline int ZfGetIntOfHex(char AC_Hex1, char AC_Hex2)
|
|
{
|
|
return ZfGetIntOfHex(AC_Hex1)*16 + ZfGetIntOfHex(AC_Hex2) ;
|
|
}/*
|
|
inline int ZfGetIntOfHex(char AC_Hex1, char AC_Hex2)*/
|
|
|
|
static char ZfGetHexCharOfInt(int AI_Integer)
|
|
{
|
|
switch(AI_Integer)
|
|
{
|
|
case 0 : case 1 :
|
|
case 2 : case 3 :
|
|
case 4 : case 5 :
|
|
case 6 : case 7 :
|
|
case 8 : case 9 : return AI_Integer+'0';
|
|
|
|
case 10 : return 'A';
|
|
case 11 : return 'B';
|
|
case 12 : return 'C';
|
|
case 13 : return 'D';
|
|
case 14 : return 'E';
|
|
case 15 : return 'F';
|
|
};/*
|
|
switch(AI_Integer)*/
|
|
|
|
return char(-1);
|
|
}/*
|
|
static char ZfGetHexCharOfInt(int AI_Integer)*/
|
|
|
|
inline void ZfGetHexCharOfInt(char AC_Int, char& AC_Hex1, char& AC_Hex2)
|
|
{
|
|
// AC_Int 의 값을 2 바이트의 16 진수 표현으로 바꾸어서 AC_Hex1, AC_Hex2 에 전달한다.
|
|
|
|
AC_Hex1= ZfGetHexCharOfInt(int((unsigned char)AC_Int)/16);
|
|
AC_Hex2= ZfGetHexCharOfInt(int((unsigned char)AC_Int)%16);
|
|
}/*
|
|
inline void ZfGetHexCharOfInt(char AC_Int, char& AC_Hex1, char& AC_Hex2)*/
|
|
|
|
|
|
template<typename TString> void ZftGetBinHexEnc
|
|
(const char* APC_Binary, int AI_Length, TString& ARR_CStringHex)
|
|
{
|
|
/* binary 포맷으로 되어 있는 데이타 APC_Binary 을 Hex 포맷으로 바꾼다.
|
|
Hex 포맷은 1 바이트를 2 바이트의 16 진수로 바꾼 것이다.
|
|
|
|
ex) binary 를 10FF780ABA 와 같은 Hex 로 바꾼다. */
|
|
|
|
if(AI_Length<1) return;
|
|
|
|
|
|
int VI_PrevBuffSize = ARR_CStringHex.size();
|
|
|
|
ARR_CStringHex.resize
|
|
(VI_PrevBuffSize+AI_Length*2, ' ');
|
|
|
|
int VI_LoopNo =AI_Length ; const ///////
|
|
char* VC_TmpChar1 =APC_Binary;
|
|
char* VC_TmpChar2 =
|
|
ARR_CStringHex.data() + VI_PrevBuffSize ;
|
|
|
|
for(int i=0;i<VI_LoopNo;++i)
|
|
{
|
|
ZfGetHexCharOfInt
|
|
( *VC_TmpChar1++, RR(*VC_TmpChar2), RR(*(VC_TmpChar2+1)) );
|
|
|
|
VC_TmpChar2 += 2;
|
|
}/*
|
|
for(int i=0;i<VI_LoopNo;++i)*/
|
|
}/*
|
|
template<typename TString> void ZftGetBinHexEnc
|
|
(const char* APC_Binary, int AI_Length, TString& ARR_CStringHex) */
|
|
|
|
template<typename TString> void ZftGetBinHexEnc
|
|
(const TString& AR_CStringBin, TString& ARR_CStringHex)
|
|
{
|
|
ZftGetBinHexEnc(AR_CStringBin.data(), AR_CStringBin.size(), RR(ARR_CStringHex));
|
|
}/*
|
|
template<typename TString> void ZftGetBinHexEnc
|
|
(const TString& AR_CStringBin, TString& ARR_CStringHex) */
|
|
|
|
|
|
template<typename TString> bool ZftGetBinHexDec
|
|
(const char* APC_HexData, int AI_Length, TString& ARR_CStringBin)
|
|
{
|
|
/* Hex 포맷으로 되어 있는 패킷 APC_HexData 을 binary 포맷으로 바꾼다.
|
|
Hex 포맷은 1 바이트를 2 바이트의 16 진수로 바꾼 것이다.
|
|
|
|
ex) 10FF780ABA 형식을 binary 로 바꾼다.
|
|
*/
|
|
int VI_LoopNo=AI_Length/2;
|
|
|
|
if(VI_LoopNo<1) return false;
|
|
|
|
int VI_PrevBuffSize=ARR_CStringBin.size();
|
|
|
|
ARR_CStringBin.resize(VI_PrevBuffSize+VI_LoopNo, ' ');
|
|
|
|
VI_LoopNo *= 2; const
|
|
|
|
char* VC_TmpChar1 = APC_HexData ;
|
|
char* VC_TmpChar2 =
|
|
ARR_CStringBin.data() + VI_PrevBuffSize ;
|
|
|
|
for(int i=0; i<VI_LoopNo; i+=2)
|
|
{
|
|
*VC_TmpChar2++ = (char)ZfGetIntOfHex(*VC_TmpChar1, *(VC_TmpChar1+1));
|
|
VC_TmpChar1 += 2;
|
|
}/*
|
|
for(int i=0; i<VI_LoopNo; i+=2)*/
|
|
|
|
return true;
|
|
}/*
|
|
template<typename TString> bool ZftGetBinHexDec
|
|
(const char* APC_HexData, int AI_Length, TString& ARR_CStringBin) */
|
|
|
|
template<typename TString> bool ZftGetBinHexDec
|
|
(const TString& AR_CStringHex, TString& ARR_CStringBin)
|
|
{
|
|
return ZftGetBinHexDec(AR_CStringHex.data(), AR_CStringHex.size(), RR(ARR_CStringBin));
|
|
}/*
|
|
template<typename TString> bool ZftGetBinHexDec
|
|
(const TString& AR_CStringHex, TString& ARR_CStringBin) */
|
|
|
|
template<typename TString, typename TIntArr> void ZftGetBinHexFormat
|
|
(
|
|
TString& ARR_CStringFormat ,
|
|
const TString& AR_CStringBin ,
|
|
const TIntArr& AR_ChunkSizeArr ,
|
|
int AI_Offset= 0 ,
|
|
const char* APC_Padd = ""
|
|
)
|
|
/*################################################################*/
|
|
{
|
|
/*///////////////////////////////////////////////////////////////
|
|
|
|
■ binary 표현 AR_CStringBin 에서 AI_Offset 번째 문자부터
|
|
'일정한 크기' 단위로 줄바꿈해서 (16 진수 포맷으로) 보여준다.
|
|
그 '일정한 크기' 를 CIntArr& AR_ChunkSizeArr 이 지정한다.
|
|
|
|
AR_ChunkSizeArr 의 원소가 3,4,5 로 되어있다면,
|
|
AR_CStringBin 의 AI_Offset 부터
|
|
3 개 바이트를 16 진수 포맷으로 출력한 다음 줄바꿈하고,
|
|
그 다음 4 개 바이트를 16 진수 포맷으로 출력한 다음 줄바꿈하고,
|
|
그 다음 5 개 바이트를 16 진수 포맷으로 출력한 다음 줄바꿈한다.
|
|
|
|
///////////////////////////////////////////////////////////////*/
|
|
|
|
int VI_ArrSize=AR_ChunkSizeArr.size(); int VI_LoopCnt=0;
|
|
|
|
if(AR_CStringBin.size()<=AI_Offset) return; /*#########*/
|
|
|
|
// 이전에는 VO_CStringBuff2 에 십진표기를 담았었다. 2009-12-18 21:22:00
|
|
|
|
TString VO_CStringBuff ;
|
|
//TString VO_CStringBuff2;
|
|
|
|
char VC_Char1=0; char VC_Char2=0;
|
|
|
|
const char* VPC_Binary = AR_CStringBin.data()+AI_Offset;
|
|
|
|
for(int i=1; i<=VI_ArrSize; ++i)
|
|
{
|
|
int VI_ChunkSize=AR_ChunkSizeArr[i-1];
|
|
|
|
VO_CStringBuff =APC_Padd; // 패딩을 한다.
|
|
//VO_CStringBuff2=" ☞ 십진표기(문자) : ";
|
|
|
|
for(int j=1; j<=VI_ChunkSize; ++j)
|
|
{
|
|
if((VI_LoopCnt++)+AI_Offset>=AR_CStringBin.size())
|
|
{
|
|
ARR_CStringFormat(" "); return;
|
|
}/*
|
|
if((VI_LoopCnt++)+AI_Offset>=AR_CStringBin.size())*/
|
|
|
|
ZfGetHexCharOfInt(*VPC_Binary,RR(VC_Char1),RR(VC_Char2));
|
|
|
|
VO_CStringBuff(VC_Char1)(VC_Char2)(" ");
|
|
|
|
/*////////////////////////////////////////////////////////////
|
|
|
|
if(*VPC_Binary==0)
|
|
VO_CStringBuff2("0(NULL) ");
|
|
else
|
|
VO_CStringBuff2(int(*VPC_Binary))("(")(*VPC_Binary)(") ");
|
|
//endif
|
|
|
|
////////////////////////////////////////////////////////////*/
|
|
|
|
++VPC_Binary;
|
|
}/*
|
|
for(int j=1; j<=VI_ChunkSize; ++j)*/
|
|
|
|
ARR_CStringFormat(VO_CStringBuff)/*(VO_CStringBuff2)*/;
|
|
|
|
if(VI_LoopCnt+AI_Offset>=AR_CStringBin.size())
|
|
{
|
|
ARR_CStringFormat(" "); return;
|
|
}/*
|
|
if(VI_LoopCnt+AI_Offset>=AR_CStringBin.size())*/
|
|
|
|
ARR_CStringFormat("\r\n");
|
|
}/*
|
|
for(int i=1; i<=VI_ArrSize; ++i)*/
|
|
|
|
|
|
if(VI_LoopCnt+AI_Offset<AR_CStringBin.size())
|
|
{
|
|
VO_CStringBuff = APC_Padd;
|
|
|
|
for(int i=VI_LoopCnt+AI_Offset; i<AR_CStringBin.size(); ++i)
|
|
{
|
|
ZfGetHexCharOfInt(*VPC_Binary++, RR(VC_Char1), RR(VC_Char2));
|
|
|
|
VO_CStringBuff(VC_Char1)(VC_Char2)(" ");
|
|
}/*
|
|
for(int i=VI_LoopCnt+AI_Offset; i<AR_CStringBin.size(); ++i)*/
|
|
|
|
ARR_CStringFormat(VO_CStringBuff);
|
|
}/*
|
|
if(VI_LoopCnt+AI_Offset<AR_CStringBin.size())*/
|
|
|
|
ARR_CStringFormat(" ");
|
|
}/*
|
|
template<typename TString, typename TIntArr> void ZftGetBinHexFormat
|
|
(
|
|
TString& ARR_CStringFormat ,
|
|
const TString& AR_CStringBin ,
|
|
const TIntArr& AR_ChunkSizeArr ,
|
|
int AI_Offset= 0 ,
|
|
const char* APC_Padd = ""
|
|
)
|
|
##################################################################*/
|
|
|
|
template<typename TString> void ZftGetBinHexFormat /*#############*/
|
|
(
|
|
TString& ARR_CStringFormat ,
|
|
const TString& AR_CStringBin ,
|
|
const int AIA_ChunkSizeArr[],
|
|
int AI_ArrSize ,
|
|
int AI_Offset= 0 ,
|
|
const char* APC_Padd = ""
|
|
)
|
|
/*################################################################*/
|
|
{
|
|
/*///////////////////////////////////////////////////////////////
|
|
|
|
■ binary 표현 AR_CStringBin 에서 AI_Offset 번째 문자부터
|
|
'일정한 크기' 단위로 줄바꿈해서 (16 진수 포맷으로) 보여준다.
|
|
그 '일정한 크기' 를 CIntArr& AR_ChunkSizeArr 이 지정한다.
|
|
|
|
AR_ChunkSizeArr 의 원소가 3,4,5 로 되어있다면,
|
|
AR_CStringBin 의 AI_Offset 부터
|
|
3 개 바이트를 16 진수 포맷으로 출력한 다음 줄바꿈하고,
|
|
그 다음 4 개 바이트를 16 진수 포맷으로 출력한 다음 줄바꿈하고,
|
|
그 다음 5 개 바이트를 16 진수 포맷으로 출력한 다음 줄바꿈한다.
|
|
|
|
///////////////////////////////////////////////////////////////*/
|
|
|
|
int VI_LoopCnt=0; if(AR_CStringBin.size()<=AI_Offset) return;
|
|
|
|
// 이전에는 VO_CStringBuff2 에 십진표기를 담았었다. 2009-12-18 21:22:00
|
|
|
|
TString VO_CStringBuff ;
|
|
//TString VO_CStringBuff2;
|
|
|
|
char VC_Char1=0; char VC_Char2=0;
|
|
|
|
const char* VPC_Binary=AR_CStringBin.data()+AI_Offset;
|
|
|
|
for(int i=1; i<=AI_ArrSize; ++i)
|
|
{
|
|
int VI_ChunkSize=AIA_ChunkSizeArr[i-1];
|
|
|
|
VO_CStringBuff =APC_Padd; // 패딩을 한다.
|
|
//VO_CStringBuff2=" ☞ 십진표기(문자) : ";
|
|
|
|
for(int j=1; j<=VI_ChunkSize; ++j)
|
|
{
|
|
if((VI_LoopCnt++)+AI_Offset>=AR_CStringBin.size())
|
|
{
|
|
ARR_CStringFormat(" "); return;
|
|
}/*
|
|
if((VI_LoopCnt++)+AI_Offset>=AR_CStringBin.size())*/
|
|
|
|
ZfGetHexCharOfInt(*VPC_Binary, RR(VC_Char1), RR(VC_Char2));
|
|
|
|
VO_CStringBuff(VC_Char1)(VC_Char2)(" ");
|
|
|
|
/*////////////////////////////////////////////////////////////
|
|
|
|
if(*VPC_Binary==0)
|
|
VO_CStringBuff2("0(NULL) ");
|
|
else
|
|
VO_CStringBuff2(int(*VPC_Binary))("(")(*VPC_Binary)(") ");
|
|
//else
|
|
|
|
////////////////////////////////////////////////////////////*/
|
|
|
|
++VPC_Binary;
|
|
}/*
|
|
for(int j=1; j<=VI_ChunkSize; ++j)*/
|
|
|
|
ARR_CStringFormat(VO_CStringBuff)/*(VO_CStringBuff2)*/;
|
|
|
|
if(VI_LoopCnt+AI_Offset>=AR_CStringBin.size())
|
|
{
|
|
ARR_CStringFormat(" "); return;
|
|
}/*
|
|
if(VI_LoopCnt+AI_Offset>=AR_CStringBin.size())*/
|
|
|
|
ARR_CStringFormat("\r\n");
|
|
}/*
|
|
for(int i=1; i<=AI_ArrSize; ++i)*/
|
|
|
|
|
|
if(VI_LoopCnt+AI_Offset<AR_CStringBin.size())
|
|
{
|
|
VO_CStringBuff=APC_Padd;
|
|
|
|
for(int i=VI_LoopCnt+AI_Offset; i<AR_CStringBin.size(); ++i)
|
|
{
|
|
ZfGetHexCharOfInt(*VPC_Binary++, RR(VC_Char1), RR(VC_Char2));
|
|
|
|
VO_CStringBuff(VC_Char1)(VC_Char2)(" ");
|
|
}/*
|
|
for(int i=VI_LoopCnt+AI_Offset; i<AR_CStringBin.size(); ++i)*/
|
|
|
|
ARR_CStringFormat(VO_CStringBuff);
|
|
}/*
|
|
if(VI_LoopCnt+AI_Offset<AR_CStringBin.size())*/
|
|
|
|
ARR_CStringFormat(" ");
|
|
}/*
|
|
template<typename TString> void ZftGetBinHexFormat #################
|
|
(
|
|
TString& ARR_CStringFormat ,
|
|
const TString& AR_CStringBin ,
|
|
const int AIA_ChunkSizeArr[],
|
|
int AI_ArrSize ,
|
|
int AI_Offset= 0 ,
|
|
const char* APC_Padd = ""
|
|
)
|
|
##################################################################*/
|
|
|
|
|
|
template<typename TString> void ZftGetBinHexFormat /*#############*/
|
|
(
|
|
TString& ARR_CStringFormat ,
|
|
const char* APC_DataBin ,
|
|
int AI_DataLen ,
|
|
const int AIA_ChunkSizeArr[],
|
|
int AI_ArrSize ,
|
|
int AI_Offset= 0 ,
|
|
const char* APC_Padd = ""
|
|
)
|
|
/*################################################################*/
|
|
{
|
|
int VI_LoopCnt=0; if(AI_DataLen<=AI_Offset) return;
|
|
|
|
|
|
TString VO_CStringBuff ;
|
|
//TString VO_CStringBuff2;
|
|
|
|
char VC_Char1 = 0; char VC_Char2=0;
|
|
const char* VPC_Binary= APC_DataBin+AI_Offset;
|
|
|
|
for(int i=1; i<=AI_ArrSize; ++i)
|
|
{
|
|
int VI_ChunkSize=AIA_ChunkSizeArr[i-1];
|
|
|
|
VO_CStringBuff =APC_Padd; // 패딩을 한다.
|
|
//VO_CStringBuff2=" ☞ 십진표기(문자) : ";
|
|
|
|
for(int j=1; j<=VI_ChunkSize; ++j)
|
|
{
|
|
if((VI_LoopCnt++)+AI_Offset>=AI_DataLen)
|
|
{
|
|
ARR_CStringFormat(" "); return;
|
|
}/*
|
|
if((VI_LoopCnt++)+AI_Offset>=AI_DataLen)*/
|
|
|
|
ZfGetHexCharOfInt(*VPC_Binary, RR(VC_Char1), RR(VC_Char2));
|
|
|
|
VO_CStringBuff(VC_Char1)(VC_Char2)(" ");
|
|
|
|
/*////////////////////////////////////////////////////////////
|
|
|
|
if(*VPC_Binary==0)
|
|
VO_CStringBuff2("0(NULL) ");
|
|
else
|
|
VO_CStringBuff2(int(*VPC_Binary))("(")(*VPC_Binary)(") ");
|
|
//else
|
|
|
|
////////////////////////////////////////////////////////////*/
|
|
|
|
++VPC_Binary;
|
|
}/*
|
|
for(int j=1; j<=VI_ChunkSize; ++j)*/
|
|
|
|
ARR_CStringFormat(VO_CStringBuff)/*(VO_CStringBuff2)*/;
|
|
|
|
if(VI_LoopCnt+AI_Offset>=AI_DataLen)
|
|
{
|
|
ARR_CStringFormat(" "); return;
|
|
}/*
|
|
if(VI_LoopCnt+AI_Offset>=AR_CStringBin.size())*/
|
|
|
|
ARR_CStringFormat("\r\n");
|
|
}/*
|
|
for(int i=1; i<=AI_ArrSize; ++i)*/
|
|
|
|
|
|
if(VI_LoopCnt+AI_Offset<AI_DataLen)
|
|
{
|
|
VO_CStringBuff = APC_Padd;
|
|
|
|
for(int i=VI_LoopCnt+AI_Offset; i<AI_DataLen; ++i)
|
|
{
|
|
ZfGetHexCharOfInt(*VPC_Binary++, RR(VC_Char1), RR(VC_Char2));
|
|
|
|
VO_CStringBuff(VC_Char1)(VC_Char2)(" ");
|
|
}/*
|
|
for(int i=VI_LoopCnt+AI_Offset; i<AI_DataLen; ++i)*/
|
|
|
|
ARR_CStringFormat(VO_CStringBuff);
|
|
}/*
|
|
if(VI_LoopCnt+AI_Offset<AI_DataLen)*/
|
|
|
|
ARR_CStringFormat(" ");
|
|
}/*
|
|
template<typename TString> void ZftGetBinHexFormat #################
|
|
(
|
|
TString& ARR_CStringFormat ,
|
|
const char* APC_DataBin ,
|
|
int AI_DataLen ,
|
|
const int AIA_ChunkSizeArr[],
|
|
int AI_ArrSize ,
|
|
int AI_Offset= 0 ,
|
|
const char* APC_Padd = ""
|
|
)
|
|
##################################################################*/
|
|
|
|
|
|
template
|
|
<typename TString, typename TIntArr, typename TTitleArr> //####
|
|
void ZftGetBinHexFormatEx
|
|
(
|
|
TString& ARR_CStringFormat ,
|
|
const TString& AR_CStringBin ,
|
|
const TIntArr& AR_ChunkSizeArr ,
|
|
const TTitleArr& AR_CStringTitleArr , // 각 줄바꿈 행 제목(문자열 object 배열)
|
|
int AI_Offset=0 ,
|
|
const char* APC_Padd =""
|
|
)
|
|
/*################################################################*/
|
|
{
|
|
/*///////////////////////////////////////////////////////////////
|
|
|
|
■ AR_ChunkSizeArr 가 지정하는 단위마다 줄바꿈 할 때마다,
|
|
AR_CStringTitleArr 이 지정하는 제목(문자열)을 함께 출력한다.
|
|
|
|
-- 2009-12-25 13:35:00
|
|
|
|
///////////////////////////////////////////////////////////////*/
|
|
|
|
int VI_ArrSize=AR_ChunkSizeArr.size(); int VI_LoopCnt=0;
|
|
|
|
if(AR_CStringBin.size()<=AI_Offset) return; /*########*/
|
|
|
|
// 이전에는 VO_CStringBuff2 에 십진표기를 담았었다. 2009-12-18 21:22:00
|
|
|
|
TString VO_CStringBuff ;
|
|
//TString VO_CStringBuff2;
|
|
|
|
char VC_Char1=0; char VC_Char2=0;
|
|
|
|
const char* VPC_Binary=AR_CStringBin.data()+AI_Offset;
|
|
|
|
for(int i=1;i<=VI_ArrSize;++i)
|
|
{
|
|
int VI_ChunkSize=AR_ChunkSizeArr[i-1];
|
|
|
|
VO_CStringBuff =APC_Padd; // 패딩을 한다.
|
|
//VO_CStringBuff2=" ☞ 십진표기(문자) : ";
|
|
|
|
if(AR_CStringTitleArr.size()>=i)
|
|
VO_CStringBuff(VO_CStringBuff)()(AR_CStringTitleArr[i-1]);
|
|
|
|
for(int j=1; j<=VI_ChunkSize; ++j)
|
|
{
|
|
if((VI_LoopCnt++)+AI_Offset>=AR_CStringBin.size())
|
|
{
|
|
ARR_CStringFormat(" "); return;
|
|
}/*
|
|
if((VI_LoopCnt++)+AI_Offset>=AR_CStringBin.size())*/
|
|
|
|
ZfGetHexCharOfInt(*VPC_Binary, RR(VC_Char1), RR(VC_Char2));
|
|
|
|
VO_CStringBuff(VC_Char1)(VC_Char2)(" ");
|
|
|
|
/*////////////////////////////////////////////////////////////
|
|
|
|
if(*VPC_Binary==0)
|
|
VO_CStringBuff2("0(NULL) ");
|
|
else
|
|
VO_CStringBuff2(int(*VPC_Binary))("(")(*VPC_Binary)(") ");
|
|
//else
|
|
|
|
////////////////////////////////////////////////////////////*/
|
|
|
|
++VPC_Binary;
|
|
}/*
|
|
for(int j=1; j<=VI_ChunkSize; ++j)*/
|
|
|
|
ARR_CStringFormat(VO_CStringBuff)/*(VO_CStringBuff2)*/;
|
|
|
|
if(VI_LoopCnt+AI_Offset>=AR_CStringBin.size())
|
|
{
|
|
ARR_CStringFormat(" "); return;
|
|
}/*
|
|
if(VI_LoopCnt+AI_Offset>=AR_CStringBin.size())*/
|
|
|
|
ARR_CStringFormat("\r\n");
|
|
}/*
|
|
for(int i=1; i<=VI_ArrSize; ++i)*/
|
|
|
|
|
|
if(VI_LoopCnt+AI_Offset < AR_CStringBin.size())
|
|
{
|
|
VO_CStringBuff=APC_Padd;
|
|
|
|
if(AR_CStringTitleArr.size()>VI_ArrSize)
|
|
VO_CStringBuff(VO_CStringBuff)()(AR_CStringTitleArr[VI_ArrSize]);
|
|
|
|
for(int i=VI_LoopCnt+AI_Offset; i<AR_CStringBin.size(); ++i)
|
|
{
|
|
ZfGetHexCharOfInt(
|
|
*VPC_Binary++,RR(VC_Char1), RR(VC_Char2) );
|
|
|
|
VO_CStringBuff(VC_Char1)(VC_Char2)(" ");
|
|
}/*
|
|
for(int i=VI_LoopCnt+AI_Offset; i<AR_CStringBin.size(); ++i)*/
|
|
|
|
ARR_CStringFormat(VO_CStringBuff);
|
|
}/*
|
|
if(VI_LoopCnt+AI_Offset < AR_CStringBin.size())*/
|
|
|
|
ARR_CStringFormat(" ");
|
|
}/*
|
|
template
|
|
<typename TString, typename TIntArr, typename TTitleArr> #######
|
|
void ZftGetBinHexFormatEx
|
|
(
|
|
TString& ARR_CStringFormat ,
|
|
const TString& AR_CStringBin ,
|
|
const TIntArr& AR_ChunkSizeArr ,
|
|
const TTitleArr& AR_CStringTitleArr ,
|
|
int AI_Offset=0 ,
|
|
const char* APC_Padd =""
|
|
)
|
|
##################################################################*/
|
|
|
|
|
|
template<typename TString> void ZftGetBinHexFormatEx( /*##########*/
|
|
TString& ARR_CStringFormat ,
|
|
const char* APC_DataBin ,
|
|
int AI_DataLen ,
|
|
const int AIA_ChunkSizeArr[] ,
|
|
int AI_ArrSize ,
|
|
const char* ASzA_TitleArr[] ,
|
|
int AI_TitleArrSize ,
|
|
int AI_Offset=0 ,
|
|
const char* APC_Padd=""
|
|
/*#########*/ ) /*################################################*/
|
|
{
|
|
int VI_LoopCnt=0; if(AI_DataLen<=AI_Offset) return;
|
|
|
|
|
|
TString VO_CStringBuff ;
|
|
//TString VO_CStringBuff2;
|
|
|
|
char VC_Char1=0; char VC_Char2=0;
|
|
|
|
const char* VPC_Binary=APC_DataBin+AI_Offset;
|
|
|
|
for(int i=1; i<=AI_ArrSize; ++i)
|
|
{
|
|
int VI_ChunkSize=AIA_ChunkSizeArr[i-1];
|
|
|
|
VO_CStringBuff =APC_Padd; // 패딩을 한다.
|
|
//VO_CStringBuff2=" ☞ 십진표기(문자) : ";
|
|
|
|
if(AI_TitleArrSize>=i)
|
|
VO_CStringBuff(ASzA_TitleArr[i-1]);
|
|
|
|
for(int j=1; j<=VI_ChunkSize; ++j)
|
|
{
|
|
if((VI_LoopCnt++)+AI_Offset>=AI_DataLen)
|
|
{
|
|
ARR_CStringFormat(" "); return;
|
|
}
|
|
/*$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$*/
|
|
|
|
ZfGetHexCharOfInt(*VPC_Binary,RR(VC_Char1), RR(VC_Char2));
|
|
|
|
VO_CStringBuff(VC_Char1)(VC_Char2)(" ");
|
|
|
|
/*////////////////////////////////////////////////////////////
|
|
|
|
if(*VPC_Binary==0)
|
|
VO_CStringBuff2("0(NULL) ");
|
|
else
|
|
VO_CStringBuff2(int(*VPC_Binary))("(")(*VPC_Binary)(") ");
|
|
//endif
|
|
|
|
////////////////////////////////////////////////////////////*/
|
|
|
|
++VPC_Binary;
|
|
}/*
|
|
for(int j=1; j<=VI_ChunkSize; ++j)*/
|
|
|
|
ARR_CStringFormat(VO_CStringBuff)/*(VO_CStringBuff2)*/;
|
|
|
|
if(VI_LoopCnt+AI_Offset>=AI_DataLen)
|
|
{
|
|
ARR_CStringFormat(" "); return;
|
|
}
|
|
/*////////////////////////////////*/
|
|
|
|
ARR_CStringFormat("\r\n");
|
|
}/*
|
|
for(int i=1; i<=AI_ArrSize; ++i)*/
|
|
|
|
|
|
if(VI_LoopCnt+AI_Offset < AI_DataLen)
|
|
{
|
|
VO_CStringBuff=APC_Padd;
|
|
|
|
if(AI_TitleArrSize>AI_ArrSize)
|
|
VO_CStringBuff(ASzA_TitleArr[AI_ArrSize]);
|
|
|
|
for(int i=VI_LoopCnt+AI_Offset; i<AI_DataLen; ++i)
|
|
{
|
|
ZfGetHexCharOfInt
|
|
(*VPC_Binary++, RR(VC_Char1), RR(VC_Char2));
|
|
|
|
VO_CStringBuff(VC_Char1)(VC_Char2)(" ");
|
|
}/*
|
|
for(int i=VI_LoopCnt+AI_Offset; i<AI_DataLen; ++i)*/
|
|
|
|
ARR_CStringFormat(VO_CStringBuff);
|
|
}/*
|
|
if(VI_LoopCnt+AI_Offset < AI_DataLen)*/
|
|
|
|
ARR_CStringFormat(" ");
|
|
}/*
|
|
template<typename TString> void ZftGetBinHexFormatEx( #############
|
|
TString& ARR_CStringFormat ,
|
|
const char* APC_DataBin ,
|
|
int AI_DataLen ,
|
|
const int AIA_ChunkSizeArr[] ,
|
|
int AI_ArrSize ,
|
|
const char* ASzA_TitleArr[] ,
|
|
int AI_TitleArrSize ,
|
|
int AI_Offset=0 ,
|
|
const char* APC_Padd=""
|
|
############# ) #################################################*/
|
|
|
|
|
|
class ZCBase64
|
|
{
|
|
public:
|
|
|
|
template<typename TString> static void Encode
|
|
(const char* APC_Origin, long AL_Length, TString& ARR_CStringEnc)
|
|
{
|
|
ZNsMain::ZNsEnc::ZftGetBase64Enc((const unsigned char*)APC_Origin, AL_Length, RR(ARR_CStringEnc));
|
|
}/*
|
|
template<typename TString> static void Encode
|
|
(const char* APC_Origin, long AL_Length, TString& ARR_CStringEnc) */
|
|
|
|
template<typename TString> static void Encode
|
|
(const TString& ARR_CStringOri, TString& ARR_CStringEnc)
|
|
{
|
|
Encode(ARR_CStringOri.data(), ARR_CStringOri.size(), RR(ARR_CStringEnc));
|
|
}/*
|
|
template<typename TString> static void Encode
|
|
(const TString& ARR_CStringOri, TString& ARR_CStringEnc) */
|
|
|
|
template<typename TString> static void Decode
|
|
(const char* APC_Origin, long AL_Length, TString& ARR_CStringDec)
|
|
{
|
|
ZNsMain::ZNsEnc::ZftGetBase64Dec
|
|
((const unsigned char*)APC_Origin, AL_Length, RR(ARR_CStringDec));
|
|
}/*
|
|
template<typename TString> static void Decode
|
|
(const char* APC_Origin, long AL_Length, TString& ARR_CStringDec) */
|
|
|
|
template<typename TString> static void Decode
|
|
(const TString& ARR_CStringOri, TString& ARR_CStringDec)
|
|
{
|
|
Decode(ARR_CStringOri.data(), ARR_CStringOri.size(), RR(ARR_CStringDec));
|
|
}/*
|
|
template<typename TString> static void Decode
|
|
(const TString& ARR_CStringOri, TString& ARR_CStringDec) */
|
|
|
|
public:
|
|
};/*
|
|
class ZCBase64*/
|
|
|
|
|
|
class ZCSha1
|
|
{
|
|
public :
|
|
|
|
enum EResult
|
|
{
|
|
EResult_Success ,
|
|
EResult_TooLong , /* input data too long */
|
|
EResult_Error /* called Input after Result */
|
|
};/*
|
|
enum EResult*/
|
|
|
|
public :
|
|
enum{ ESHA1HashSize = 20 } ;
|
|
public :
|
|
typedef uint8_t
|
|
UInt8Digest[ESHA1HashSize];
|
|
private:
|
|
|
|
struct StContext
|
|
{
|
|
uint32_t muia_IntermedHash[ESHA1HashSize/4]; /* Message Digest Intermediate Hash */
|
|
|
|
uint32_t mui_LengthLow ; /* Message length in bits */
|
|
uint32_t mui_LengthHigh ; /* Message length in bits */
|
|
int16_t mi_MsgBlockIndex ; /* Index into message block array, 최소 16 bit 이상의 크기 정수 */
|
|
uint8_t muca_MsgBlock[64] ; /* 512-bit message blocks */
|
|
|
|
int mb_IsComputed ; /* Is the digest computed? */
|
|
EResult me_EResult ; /* Is the message digest corrupted? */
|
|
};/*
|
|
struct StContext*/
|
|
|
|
private:
|
|
|
|
#define SHA1CircularShift(bits,word) \
|
|
(((word) << (bits)) | ((word) >> (32-(bits))))
|
|
|
|
private:
|
|
StContext mo_StContext;
|
|
UInt8Digest muca_Digest ;
|
|
private:
|
|
|
|
|
|
void InitContext()
|
|
{
|
|
mo_StContext.mui_LengthLow = 0 ;
|
|
mo_StContext.mui_LengthHigh = 0 ;
|
|
mo_StContext.mi_MsgBlockIndex = 0 ;
|
|
|
|
mo_StContext.muia_IntermedHash[0] = 0x67452301;
|
|
mo_StContext.muia_IntermedHash[1] = 0xEFCDAB89;
|
|
mo_StContext.muia_IntermedHash[2] = 0x98BADCFE;
|
|
mo_StContext.muia_IntermedHash[3] = 0x10325476;
|
|
mo_StContext.muia_IntermedHash[4] = 0xC3D2E1F0;
|
|
|
|
mo_StContext.mb_IsComputed = false ;
|
|
mo_StContext.me_EResult = EResult_Success;
|
|
}/*
|
|
void InitContext()*/
|
|
|
|
void HandleMsgBlock()
|
|
{
|
|
const uint32_t K[] = /* Constants defined in SHA-1 */
|
|
{
|
|
0x5A827999,
|
|
0x6ED9EBA1,
|
|
0x8F1BBCDC,
|
|
0xCA62C1D6
|
|
};/*
|
|
const uint32_t K[] = */
|
|
|
|
int t ; /* Loop counter */
|
|
uint32_t temp; /* Temporary word value */
|
|
uint32_t W[80]; /* Word sequence */
|
|
uint32_t A, B, C, D, E; /* Word buffers */
|
|
|
|
/*
|
|
* Initialize the first 16 words in the array W
|
|
*/
|
|
for(t = 0; t < 16; t++)
|
|
{
|
|
W[t] = mo_StContext.muca_MsgBlock[t * 4 ] << 24;
|
|
W[t] |= mo_StContext.muca_MsgBlock[t * 4 + 1] << 16;
|
|
W[t] |= mo_StContext.muca_MsgBlock[t * 4 + 2] << 8 ;
|
|
W[t] |= mo_StContext.muca_MsgBlock[t * 4 + 3];
|
|
}/*
|
|
for(t = 0; t < 16; t++)*/
|
|
|
|
for(t = 16; t < 80; t++)
|
|
{
|
|
W[t] = SHA1CircularShift(1,W[t-3] ^ W[t-8] ^ W[t-14] ^ W[t-16]);
|
|
}/*
|
|
for(t = 16; t < 80; t++)*/
|
|
|
|
A = mo_StContext.muia_IntermedHash[0];
|
|
B = mo_StContext.muia_IntermedHash[1];
|
|
C = mo_StContext.muia_IntermedHash[2];
|
|
D = mo_StContext.muia_IntermedHash[3];
|
|
E = mo_StContext.muia_IntermedHash[4];
|
|
|
|
for(t = 0; t < 20; t++)
|
|
{
|
|
temp = SHA1CircularShift(5,A) +
|
|
((B & C) | ((~B) & D)) + E + W[t] + K[0];
|
|
E = D;
|
|
D = C;
|
|
C = SHA1CircularShift(30,B);
|
|
|
|
B = A;
|
|
A = temp;
|
|
}/*
|
|
for(t = 0; t < 20; t++)*/
|
|
|
|
for(t = 20; t < 40; t++)
|
|
{
|
|
temp = SHA1CircularShift(5,A) + (B ^ C ^ D) + E + W[t] + K[1];
|
|
E = D;
|
|
D = C;
|
|
C = SHA1CircularShift(30,B);
|
|
B = A;
|
|
A = temp;
|
|
}/*
|
|
for(t = 20; t < 40; t++)*/
|
|
|
|
for(t = 40; t < 60; t++)
|
|
{
|
|
temp = SHA1CircularShift(5,A) +
|
|
((B & C) | (B & D) | (C & D)) + E + W[t] + K[2];
|
|
E = D;
|
|
D = C;
|
|
C = SHA1CircularShift(30,B);
|
|
B = A;
|
|
A = temp;
|
|
}/*
|
|
for(t = 40; t < 60; t++)*/
|
|
|
|
for(t = 60; t < 80; t++)
|
|
{
|
|
temp = SHA1CircularShift(5,A) + (B ^ C ^ D) + E + W[t] + K[3];
|
|
E = D;
|
|
D = C;
|
|
C = SHA1CircularShift(30,B);
|
|
B = A;
|
|
A = temp;
|
|
}/*
|
|
for(t = 60; t < 80; t++)*/
|
|
|
|
mo_StContext.muia_IntermedHash[0] += A;
|
|
mo_StContext.muia_IntermedHash[1] += B;
|
|
mo_StContext.muia_IntermedHash[2] += C;
|
|
mo_StContext.muia_IntermedHash[3] += D;
|
|
mo_StContext.muia_IntermedHash[4] += E;
|
|
|
|
mo_StContext.mi_MsgBlockIndex = 0;
|
|
}/*
|
|
void HandleMsgBlock()*/
|
|
|
|
void PadMessage()
|
|
{
|
|
/*
|
|
* Check to see if the current message block is too small to hold
|
|
* the initial padding bits and length. If so, we will pad the
|
|
* block, process it, and then continue padding into a second
|
|
* block.
|
|
*/
|
|
if(mo_StContext.mi_MsgBlockIndex > 55)
|
|
{
|
|
mo_StContext.muca_MsgBlock[mo_StContext.mi_MsgBlockIndex++] = 0x80;
|
|
|
|
while(mo_StContext.mi_MsgBlockIndex < 64)
|
|
mo_StContext.muca_MsgBlock[mo_StContext.mi_MsgBlockIndex++] = 0;
|
|
|
|
HandleMsgBlock();
|
|
|
|
while(mo_StContext.mi_MsgBlockIndex < 56)
|
|
mo_StContext.muca_MsgBlock[mo_StContext.mi_MsgBlockIndex++] = 0;
|
|
}
|
|
else // mo_StContext.mi_MsgBlockIndex <= 55
|
|
{
|
|
mo_StContext.muca_MsgBlock[mo_StContext.mi_MsgBlockIndex++] = 0x80;
|
|
|
|
while(mo_StContext.mi_MsgBlockIndex < 56)
|
|
mo_StContext.muca_MsgBlock[mo_StContext.mi_MsgBlockIndex++] = 0;
|
|
}/*
|
|
else // mo_StContext.mi_MsgBlockIndex <= 55 */
|
|
|
|
/*
|
|
* Store the message length as the last 8 octets
|
|
*/
|
|
mo_StContext.muca_MsgBlock[56] = mo_StContext.mui_LengthHigh >> 24;
|
|
mo_StContext.muca_MsgBlock[57] = mo_StContext.mui_LengthHigh >> 16;
|
|
mo_StContext.muca_MsgBlock[58] = mo_StContext.mui_LengthHigh >> 8 ;
|
|
mo_StContext.muca_MsgBlock[59] = mo_StContext.mui_LengthHigh ;
|
|
mo_StContext.muca_MsgBlock[60] = mo_StContext.mui_LengthLow >> 24;
|
|
mo_StContext.muca_MsgBlock[61] = mo_StContext.mui_LengthLow >> 16;
|
|
mo_StContext.muca_MsgBlock[62] = mo_StContext.mui_LengthLow >> 8 ;
|
|
mo_StContext.muca_MsgBlock[63] = mo_StContext.mui_LengthLow ;
|
|
|
|
HandleMsgBlock();
|
|
}/*
|
|
void PadMessage()*/
|
|
|
|
void Calculate()
|
|
{
|
|
if(mo_StContext.me_EResult!=EResult_Success) return;
|
|
|
|
int i;
|
|
|
|
if(!mo_StContext.mb_IsComputed)
|
|
{
|
|
PadMessage();
|
|
|
|
for(i=0; i<64; ++i)
|
|
{
|
|
/* message may be sensitive, clear it out */
|
|
mo_StContext.muca_MsgBlock[i] = 0;
|
|
}/*
|
|
for(i=0; i<64; ++i)*/
|
|
|
|
mo_StContext.mui_LengthLow = 0; /* and clear length */
|
|
mo_StContext.mui_LengthHigh= 0;
|
|
mo_StContext.mb_IsComputed = true;
|
|
}/*
|
|
if(!mo_StContext.mb_IsComputed)*/
|
|
|
|
for(i = 0; i < ESHA1HashSize; ++i)
|
|
{
|
|
muca_Digest[i] =
|
|
mo_StContext.muia_IntermedHash[i>>2] >> 8 * ( 3 - ( i & 0x03 ) );
|
|
}/*
|
|
for(i = 0; i < ESHA1HashSize; ++i)*/
|
|
}/*
|
|
void Calculate()*/
|
|
|
|
/*private:*/
|
|
public :
|
|
|
|
void Encode(const uint8_t* APUC_Message, int AI_Length)
|
|
{
|
|
InitContext(); if (AI_Length<1) return;
|
|
|
|
|
|
while(AI_Length-->0 && mo_StContext.me_EResult==EResult_Success)
|
|
{
|
|
mo_StContext.muca_MsgBlock[mo_StContext.mi_MsgBlockIndex++] =
|
|
(*APUC_Message & 0xFF);
|
|
mo_StContext.mui_LengthLow += 8;
|
|
|
|
if(mo_StContext.mui_LengthLow == 0)
|
|
{
|
|
mo_StContext.mui_LengthHigh++;
|
|
|
|
if (mo_StContext.mui_LengthHigh == 0)
|
|
mo_StContext.me_EResult = EResult_TooLong;
|
|
}/*
|
|
if(mo_StContext.mui_LengthLow == 0)*/
|
|
|
|
if(mo_StContext.mi_MsgBlockIndex == 64)
|
|
HandleMsgBlock();
|
|
|
|
APUC_Message++;
|
|
}/*
|
|
while(AI_Length-->0 && mo_StContext.me_EResult==EResult_Success)*/
|
|
|
|
Calculate(); /////////////////////////////////////////////////////
|
|
}/*
|
|
void Encode(const uint8_t* APUC_Message, int AI_Length)*/
|
|
|
|
void Encode(const char* APC_Message, int AI_Length)
|
|
{
|
|
Encode((const uint8_t*)APC_Message, AI_Length);
|
|
}/*
|
|
void Encode(const char* APC_Message, int AI_Length)*/
|
|
|
|
void Encode(const char* APC_Message)
|
|
{
|
|
Encode(APC_Message, ZNsMain::ZftLength(APC_Message));
|
|
}/*
|
|
void Encode(const char* APC_Message)*/
|
|
|
|
template<typename TStringData> void EncodeCStr(TStringData& AR_CStringOri)
|
|
{
|
|
Encode(AR_CStringOri.data(), AR_CStringOri.size());
|
|
}/*
|
|
template<typename TStringData> void EncodeCStr(TStringData& AR_CStringOri)*/
|
|
|
|
|
|
UInt8Digest& GetDigest(){return muca_Digest;}
|
|
|
|
template<typename TStringData> void GetDigestBin(TStringData& ARR_CStringBin)
|
|
{
|
|
ARR_CStringBin((const char*)muca_Digest, ESHA1HashSize);
|
|
}/*
|
|
template<typename TStringData> void GetDigestBin(TStringData& ARR_CStringBin)*/
|
|
|
|
template<typename TStringData> void GetDigestHex(TStringData& ARR_CStringHex)
|
|
{
|
|
ARR_CStringHex.resize(ESHA1HashSize*2);
|
|
|
|
unsigned char* VPUC_Digest=muca_Digest;
|
|
|
|
for(int i=0;i<ESHA1HashSize;++i)
|
|
{
|
|
::sprintf(ARR_CStringHex.data()+i*2, "%02X", *VPUC_Digest++);
|
|
}/*
|
|
for(int i=0;i<ESHA1HashSize;++i)*/
|
|
}/*
|
|
template<typename TStringData> void GetDigestHex(TStringData& ARR_CStringHex)*/
|
|
|
|
|
|
#undef SHA1CircularShift
|
|
|
|
|
|
public :
|
|
};/*
|
|
class ZCSha1*/
|
|
|
|
}/*
|
|
namespace ZNsEnc*/
|
|
|
|
}/*
|
|
namespace ZNsMain */
|
|
|
|
|
|
/*/////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
■ namespace ZNsEnc 있는 암호 복화화 함수를 클래스가 아닌 함수로 구현되는 알고리즘이 있다면,
|
|
그 알고리즘을 MyCode 라고 부른다고 할 때,
|
|
|
|
인코딩하는 함수는 GetMyCodeEnc() 하 하고, 디코딩하는 함수는 GetMyCodeDec() 하 하자.
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////*/
|
|
|
|
|
|
#endif //__ZCPPMAIN__ZMAINENC_H__
|