00001
00022 #define DKUTIL_C_MD2_C
00023
00024
00025 #include "md_misc.h"
00026 #include "dkcMD2.h"
00027 #include "dkcStdio.h"
00028
00029
00030 DKC_MD2 *WINAPI dkcAllocMD2(){
00031 DKC_MD2 *p = dkcAllocate(sizeof(DKC_MD2));
00032 if(NULL==p) return NULL;
00033 dkcMD2Init(p);
00034 return p;
00035 }
00036
00037
00038 int WINAPI dkcFreeMD2(DKC_MD2 **pp){
00039 if(NULL==pp || NULL==*pp){
00040 return edk_FAILED;
00041 }
00042 return dkcFree((void **)pp);
00043 }
00044
00045
00046
00047 void WINAPI dkcMD2Init(DKC_MD2 *p){
00048
00049 memset(p, 0, sizeof(*p));
00050
00051 }
00052
00053
00054
00055
00056 static void hash_init (DKC_MD2 *ptr)
00057 {
00058 memset(ptr->X, 0, 48);
00059 memset(ptr->C, 0, 16);
00060 ptr->count=0;
00061 }
00062
00063 static uint8 S[256] = {
00064 41, 46, 67, 201, 162, 216, 124, 1, 61, 54, 84, 161, 236, 240, 6,
00065 19, 98, 167, 5, 243, 192, 199, 115, 140, 152, 147, 43, 217, 188,
00066 76, 130, 202, 30, 155, 87, 60, 253, 212, 224, 22, 103, 66, 111, 24,
00067 138, 23, 229, 18, 190, 78, 196, 214, 218, 158, 222, 73, 160, 251,
00068 245, 142, 187, 47, 238, 122, 169, 104, 121, 145, 21, 178, 7, 63,
00069 148, 194, 16, 137, 11, 34, 95, 33, 128, 127, 93, 154, 90, 144, 50,
00070 39, 53, 62, 204, 231, 191, 247, 151, 3, 255, 25, 48, 179, 72, 165,
00071 181, 209, 215, 94, 146, 42, 172, 86, 170, 198, 79, 184, 56, 210,
00072 150, 164, 125, 182, 118, 252, 107, 226, 156, 116, 4, 241, 69, 157,
00073 112, 89, 100, 113, 135, 32, 134, 91, 207, 101, 230, 45, 168, 2, 27,
00074 96, 37, 173, 174, 176, 185, 246, 28, 70, 97, 105, 52, 64, 126, 15,
00075 85, 71, 163, 35, 221, 81, 175, 58, 195, 92, 249, 206, 186, 197,
00076 234, 38, 44, 83, 13, 110, 133, 40, 132, 9, 211, 223, 205, 244, 65,
00077 129, 77, 82, 106, 220, 55, 200, 108, 193, 171, 250, 36, 225, 123,
00078 8, 12, 189, 177, 74, 120, 136, 149, 139, 227, 99, 232, 109, 233,
00079 203, 213, 254, 59, 0, 29, 57, 242, 239, 183, 14, 102, 88, 208, 228,
00080 166, 119, 114, 248, 235, 117, 75, 10, 49, 68, 80, 180, 143, 237,
00081 31, 26, 219, 153, 141, 51, 159, 17, 131, 20
00082 };
00083
00084 static DKC_INLINE void hash_copy(DKC_MD2 *src, DKC_MD2 *dest)
00085 {
00086 dest->count=src->count;
00087 memcpy(dest->buf, src->buf, dest->count);
00088 memcpy(dest->X, src->X, 48);
00089 memcpy(dest->C, src->C, 16);
00090 }
00091
00092
00093 static DKC_INLINE void hash_update (DKC_MD2 *self, const uint8 *buf, uint32 len)
00094 {
00095 uint32 L;
00096 while (len)
00097 {
00098 L=(16-self->count) < len ? (16-self->count) : len;
00099 memcpy(self->buf+self->count, buf, L);
00100 self->count+=L;
00101 buf+=L;
00102 len-=L;
00103 if (self->count==16)
00104 {
00105 uint8 t;
00106 int i,j;
00107
00108 self->count=0;
00109 memcpy(self->X+16, self->buf, 16);
00110 t=self->C[15];
00111 for(i=0; i<16; i++)
00112 {
00113 self->X[32+i] = (uint8)( self->X[16+i] ^ self->X[i]);
00114 t=(uint8)self->C[i] ^= S[self->buf[i]^t];
00115 }
00116
00117 t=0;
00118 for(i=0; i<18; i++)
00119 {
00120 for(j=0; j<48; j++)
00121 t=(uint8)self->X[j]^=S[t];
00122 t=(uint8)((t+i) & 0xFF);
00123 }
00124 }
00125 }
00126 }
00127
00128 static DKC_INLINE void hash_final (DKC_MD2 *self)
00129 {
00130 uint8 padding[16];
00131 uint32 padlen;
00132
00133 uint32 i;
00134
00135 memcpy(self, self, sizeof(DKC_MD2));
00136 padlen= 16-self->count;
00137 dkcmNOT_ASSERT(padlen > UCHAR_MAX);
00138 for(i=0; i<padlen; i++)
00139 padding[i]=(uint8)padlen;
00140 hash_update(self, padding, padlen);
00141 hash_update(self, self->C, 16);
00142
00143
00144
00145 }
00146
00147 static DKC_INLINE void hash_digest(const DKC_MD2 *self,uint8 *buff){
00148 memcpy(buff,self->X, 16);
00149 }
00150
00151 void WINAPI dkcMD2Load(DKC_MD2 *p,const BYTE *pBuffer,DWORD dwSize){
00152 if(p->flags & edkcMD_Finalized){
00153 return;
00154 }
00155 hash_update(p,pBuffer,dwSize);
00156 }
00157
00158
00159
00160 void WINAPI dkcMD2Final(DKC_MD2 *p){
00161
00162 if(p->flags & edkcMD_Finalized){
00163 return;
00164 }
00165 hash_final(p);
00166
00167 p->flags |= edkcMD_Finalized;
00168 }
00169
00170 int WINAPI dkcMD2Digest(DKC_MD2 *p,BYTE *buff,size_t size){
00171
00172 if(size < MD2_BIN_BUFFER_SIZE){
00173 return edk_BufferOverFlow;
00174 }
00175 hash_digest(p,buff);
00176 return edk_SUCCEEDED;
00177 }
00178
00179 int WINAPI dkcMD2DigestStr(DKC_MD2 *p,char *buff,size_t size){
00180 register int i;
00181 uint8 temp[MD2_BIN_BUFFER_SIZE];
00182 if(size < MD2_STR_BUFFER_SIZE){
00183 return edk_BufferOverFlow;
00184 }
00185 i = dkcMD2Digest(p,temp,sizeof(temp));
00186 if(DKUTIL_FAILED(i)){
00187 return i;
00188 }
00189 for (i=0; i<16; i++){
00190 sprintf(buff+i*2,"%02x", temp[i]);
00191 }
00192 buff[32]='\0';
00193 return edk_SUCCEEDED;
00194 }
00195
00196 int WINAPI dkcMD2FinalDigestStr(DKC_MD2 *p,char *buff,size_t size){
00197 dkcMD2Final(p);
00198 return dkcMD2DigestStr(p,buff,size);
00199 }
00200
00201 int WINAPI dkcMD2FinalDigest(DKC_MD2 *p,BYTE *buff,size_t size){
00202 dkcMD2Final(p);
00203 return dkcMD2Digest(p,buff,size);
00204
00205 }
00206