📄 base64md5.cpp
字号:
// Base64 MD5.cpp : Defines the class behaviors for the application.
//
#include "stdafx.h"
#include "Base64MD5.h"
void Base64::Encode(unsigned char* inBuf,int inLen,unsigned char* outBuf,int &outLen)
{
const char alphabet[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
int len = ((inLen-1)/3 + 1)*4;
if(outLen<len)return;
outLen = len;
int i,j;
unsigned long val;
int quad, trip;
for (i=0, j=0; i<inLen; i+=3, j+=4)
{
quad = 0;
trip = 0;
val = inBuf[i]; val <<= 8;
if ( (i+1) <inLen )
{
val |= inBuf[i+1];
trip = 1;
}
val <<=8;
if ( (i+2) <inLen )
{
val |= inBuf[i+2];
quad = 1;
}
outBuf[j+3] = alphabet[(quad ? (val&0x3f) : 64)]; val >>= 6;
outBuf[j+2] = alphabet[(trip ? (val&0x3f) : 64)]; val >>= 6;
outBuf[j+1] = alphabet[val & 0x3f]; val >>= 6;
outBuf[j ] = alphabet[val];
}
}
void Base64::Decode(unsigned char* inBuf,int inLen,unsigned char* outBuf,int &outLen)
{
int i,j,k;
unsigned long val;
int len=(inLen/4)*3;
if(outLen<len)return;
outLen = len;
for (i=0, j=0; i+3<inLen; i+=4, j+=3)
{
val = 0;
for ( k=i; k<i+4; k++)
{
if ( inBuf[k]>='A' && inBuf[k]<='Z' )
{
val <<= 6; val += inBuf[k] - 'A';
}
else if ( inBuf[k]>='a' && inBuf[k]<='z' )
{
val <<= 6; val += inBuf[k] - 'a' + 26;
}
else if ( inBuf[k]>='0' && inBuf[k]<='9' )
{
val <<= 6; val += inBuf[k] - '0' +52;
}
else if ( inBuf[k] == '+' )
{
val <<= 6; val += 62;
}
else if ( inBuf[k] == '/')
{
val <<= 6; val += 63;
}
else
{
val <<= 6;
}
}
outBuf[j+2] = (unsigned char)val&0xFF; val>>=8;
outBuf[j+1] = (unsigned char)val&0xFF; val>>=8;
outBuf[j ] = (unsigned char)val&0xFF;
}
}
void MD5::Init()
{
// initial the context
m_state[0] = 0x67452301;
m_state[1] = 0xEFCDAB89;
m_state[2] = 0x98BADCFE;
m_state[3] = 0x10325476;
m_tailLen = 0;
m_count[0] = m_count[1] = 0;
}
void MD5::Update(unsigned char* inBuf,int inLen)
{
int i=0, j, k;
// transform
m_count[0]+=((unsigned long)inLen<< 3);
if ( m_count[0]< ((unsigned long)inLen << 3) )
m_count[1]++;
m_count[1] += ((unsigned long)inLen >> 29);
if(m_tailLen)
{
int cpyLen = 64-m_tailLen;
if(inLen>=cpyLen )
{
memcpy(m_tail+m_tailLen, inBuf, cpyLen);
Encode( (unsigned long*)m_tail) ; m_tailLen = 0;
inBuf+= cpyLen; inLen -= cpyLen;
} else
{
memcpy( m_tail+m_tailLen, inBuf, inLen);
m_tailLen += inLen; inLen = 0;
}
}
for ( i = 0; i+63<inLen; i += 64 )
{
unsigned long x[16];
// load the 16 word session of inBuf to the working array, little-endian
for (j=0, k=0; k<64; j++, k+=4)
{
x[j] = ((unsigned long)*(inBuf+i+k)) | (((unsigned long)*(inBuf+i+k+1))<<8) | (((unsigned long)*(inBuf+i+k+2))<<16) | (((unsigned long)*(inBuf+i+k+3))<<24);
}
Encode(x) ;
}
// padding
int less = inLen&0x3F;
if(less>0)
{
memcpy(m_tail, inBuf+i, less);
m_tailLen=less;
}
TRACE(" m_tailLen==%d\n",m_tailLen);
}
void MD5::GetMD5(unsigned char* inBuf,int inLen)
{
if(inLen<16)return;
if(56<=m_tailLen)
{
m_tail[m_tailLen] = 0x80;
memset(m_tail+m_tailLen+1, 0, 63-m_tailLen);
Encode( (unsigned long*)m_tail);
memset(m_tail, 0, 56);
}else
{
m_tail[m_tailLen] = 0x80;
memset(m_tail+m_tailLen+1, 0, 55-m_tailLen);
}
int *p=(int*)m_tail;
p[14] = m_count[0];
p[15] = m_count[1];
Encode( (unsigned long*)m_tail);
m_tailLen = 0;
memcpy(inBuf, m_state, 16);
}
void MD5::Encode(unsigned long x[16])
{
unsigned long a = m_state[0], b = m_state[1], c = m_state[2], d = m_state[3];
FF(a, b, c, d, x[0], 7, 0xD76AA478);
FF(d, a, b, c, x[1], 12, 0xE8C7B756);
FF(c, d, a, b, x[2], 17, 0x242070DB);
FF(b, c, d, a, x[3], 22, 0xC1BDCEEE);
FF(a, b, c, d, x[4], 7, 0xF57C0FAF);
FF(d, a, b, c, x[5], 12, 0x4787C62A);
FF(c, d, a, b, x[6], 17, 0xA8304613);
FF(b, c, d, a, x[7], 22, 0xFD469501);
FF(a, b, c, d, x[8], 7, 0x698098D8);
FF(d, a, b, c, x[9], 12, 0x8B44F7AF);
FF(c, d, a, b, x[10], 17, 0xFFFF5BB1);
FF(b, c, d, a, x[11], 22, 0x895CD7BE);
FF(a, b, c, d, x[12], 7, 0x6B901122);
FF(d, a, b, c, x[13], 12, 0xFD987193);
FF(c, d, a, b, x[14], 17, 0xA679438E);
FF(b, c, d, a, x[15], 22, 0x49B40821);
// round 2
GG(a, b, c, d, x[1], 5, 0xF61E2562);
GG(d, a, b, c, x[6], 9, 0xC040B340);
GG(c, d, a, b, x[11], 14, 0x265E5A51);
GG(b, c, d, a, x[0], 20, 0xE9B6C7AA);
GG(a, b, c, d, x[5], 5, 0xD62F105D);
GG(d, a, b, c, x[10], 9, 0x2441453);
GG(c, d, a, b, x[15], 14, 0xD8A1E681);
GG(b, c, d, a, x[4], 20, 0xE7D3FBC8);
GG(a, b, c, d, x[9], 5, 0x21E1CDE6);
GG(d, a, b, c, x[14], 9, 0xC33707D6);
GG(c, d, a, b, x[3], 14, 0xF4D50D87);
GG(b, c, d, a, x[8], 20, 0x455A14ED);
GG(a, b, c, d, x[13], 5, 0xA9E3E905);
GG(d, a, b, c, x[2], 9, 0xFCEFA3F8);
GG(c, d, a, b, x[7], 14, 0x676F02D9);
GG(b, c, d, a, x[12], 20, 0x8D2A4C8A);
// round 3
HH(a, b, c, d, x[5], 4, 0xFFFA3942);
HH(d, a, b, c, x[8], 11, 0x8771F681);
HH(c, d, a, b, x[11], 16, 0x6D9D6122);
HH(b, c, d, a, x[14], 23, 0xFDE5380C);
HH(a, b, c, d, x[1], 4, 0xA4BEEA44);
HH(d, a, b, c, x[4], 11, 0x4BDECFA9);
HH(c, d, a, b, x[7], 16, 0xF6BB4B60);
HH(b, c, d, a, x[10], 23, 0xBEBFBC70);
HH(a, b, c, d, x[13], 4, 0x289B7EC6);
HH(d, a, b, c, x[0], 11, 0xEAA127FA);
HH(c, d, a, b, x[3], 16, 0xD4EF3085);
HH(b, c, d, a, x[6], 23, 0x4881D05);
HH(a, b, c, d, x[9], 4, 0xD9D4D039);
HH(d, a, b, c, x[12], 11, 0xE6DB99E5);
HH(c, d, a, b, x[15], 16, 0x1FA27CF8);
HH(b, c, d, a, x[2], 23, 0xC4AC5665);
// round 4
II(a, b, c, d, x[0], 6, 0xF4292244);
II(d, a, b, c, x[7], 10, 0x432AFF97);
II(c, d, a, b, x[14], 15, 0xAB9423A7);
II(b, c, d, a, x[5], 21, 0xFC93A039);
II(a, b, c, d, x[12], 6, 0x655B59C3);
II(d, a, b, c, x[3], 10, 0x8F0CCC92);
II(c, d, a, b, x[10], 15, 0xFFEFF47D);
II(b, c, d, a, x[1], 21, 0x85845DD1);
II(a, b, c, d, x[8], 6, 0x6FA87E4F);
II(d, a, b, c, x[15], 10, 0xFE2CE6E0);
II(c, d, a, b, x[6], 15, 0xA3014314);
II(b, c, d, a, x[13], 21, 0x4E0811A1);
II(a, b, c, d, x[4], 6, 0xF7537E82);
II(d, a, b, c, x[11], 10, 0xBD3AF235);
II(c, d, a, b, x[2], 15, 0x2AD7D2BB);
II(b, c, d, a, x[9], 21, 0xEB86D391);
m_state[0] += a;
m_state[1] += b;
m_state[2] += c;
m_state[3] += d;
}⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -