メインページ | アルファベット順一覧 | 構成 | ファイル一覧 | 構成メンバ | ファイルメンバ | 関連ページ

dkcMD2.c

説明を見る。
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     //DKC_MD2 temp;
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     //memcpy(buff,temp.X, 16);
00143     //return PyString_FromStringAndSize(temp.X, 16);
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     //uint8 digest[MD2_BIN_BUFFER_SIZE];
00162     if(p->flags & edkcMD_Finalized){
00163         return;
00164     }
00165     hash_final(p);
00166     //memcpy(p->u_store.a8,digest,sizeof(digest));
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 

dkutil_cに対してMon Jan 16 00:39:48 2006に生成されました。  doxygen 1.4.4