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

dkcHash.c

説明を見る。
00001 
00008 #include "dkcHash.h"
00009 #include "dkcStdio.h"
00010 
00011 
00012 void WINAPI dkcSHO_MD2Init(DKC_SECURE_HASH_OBJECT *p){
00013 
00014     p->Init = (DKC_WINAPI_PROC_F_TYPE)dkcMD2Init;
00015     p->Load = (DKC_WINAPI_PROC_F_TYPE)dkcMD2Load;
00016     p->Final = (DKC_WINAPI_PROC_F_TYPE)dkcMD2Final;
00017     p->DigestStr = (DKC_WINAPI_PROC_F_TYPE)dkcMD2DigestStr;
00018     p->Digest = (DKC_WINAPI_PROC_F_TYPE)dkcMD2Digest;
00019 
00020     p->digest_string_size = MD2_STR_BUFFER_SIZE;
00021     p->digest_binary_size = MD2_BIN_BUFFER_SIZE;
00022 
00023     p->mObj = dkcAllocMD2();
00024 
00025 
00026 }
00027 
00028 void WINAPI dkcSHO_MD4Init(DKC_SECURE_HASH_OBJECT *p){
00029 
00030     p->Init = (DKC_WINAPI_PROC_F_TYPE)dkcMD4Init;
00031     p->Load = (DKC_WINAPI_PROC_F_TYPE)dkcMD4Load;
00032     p->Final = (DKC_WINAPI_PROC_F_TYPE)dkcMD4Final;
00033     p->DigestStr = (DKC_WINAPI_PROC_F_TYPE)dkcMD4DigestStr;
00034     p->Digest = (DKC_WINAPI_PROC_F_TYPE)dkcMD4Digest;
00035 
00036     p->digest_string_size = MD4_STR_BUFFER_SIZE;
00037     p->digest_binary_size = MD4_BIN_BUFFER_SIZE;
00038 
00039     p->mObj = dkcAllocMD4();
00040 
00041 
00042 }
00043 
00044 void WINAPI dkcSHO_MD5Init(DKC_SECURE_HASH_OBJECT *p){
00045 
00046 
00047     p->Init = (DKC_WINAPI_PROC_F_TYPE)dkcMD5Init;
00048     p->Load = (DKC_WINAPI_PROC_F_TYPE)dkcMD5Load;
00049     p->Final = (DKC_WINAPI_PROC_F_TYPE)dkcMD5Final;
00050     p->DigestStr = (DKC_WINAPI_PROC_F_TYPE)dkcMD5DigestStr;
00051     p->Digest = (DKC_WINAPI_PROC_F_TYPE)dkcMD5Digest;
00052 
00053     p->digest_string_size = MD5_STR_BUFFER_SIZE;
00054     p->digest_binary_size = MD5_BIN_BUFFER_SIZE;
00055 
00056     p->mObj = dkcAllocMD5();
00057 }
00058 
00059 
00060 void WINAPI dkcSHO_SHA1Init(DKC_SECURE_HASH_OBJECT *p){
00061 
00062     p->Init = (DKC_WINAPI_PROC_F_TYPE)dkcSHA1Init;
00063     p->Load = (DKC_WINAPI_PROC_F_TYPE)dkcSHA1Load;
00064     p->Final = (DKC_WINAPI_PROC_F_TYPE)dkcSHA1Final;
00065     p->DigestStr = (DKC_WINAPI_PROC_F_TYPE)dkcSHA1DigestStr;
00066     p->Digest = (DKC_WINAPI_PROC_F_TYPE)dkcSHA1Digest;
00067 
00068     p->digest_string_size = SHA1_STR_BUFFER_SIZE;
00069     p->digest_binary_size = SHA1_BIN_BUFFER_SIZE;
00070 
00071     p->mObj = dkcAllocSHA1();
00072 }
00073 
00074 
00075 void WINAPI dkcSHO_SHA256Init(DKC_SECURE_HASH_OBJECT *p){
00076 
00077     p->Init = (DKC_WINAPI_PROC_F_TYPE)dkcSHA256Init;
00078     p->Load = (DKC_WINAPI_PROC_F_TYPE)dkcSHA256Load;
00079     p->Final = (DKC_WINAPI_PROC_F_TYPE)dkcSHA256Final;
00080     p->DigestStr = (DKC_WINAPI_PROC_F_TYPE)dkcSHA256DigestStr;
00081     p->Digest = (DKC_WINAPI_PROC_F_TYPE)dkcSHA256Digest;
00082 
00083     p->digest_string_size = SHA256_STR_BUFFER_SIZE;
00084     p->digest_binary_size = SHA256_BIN_BUFFER_SIZE;
00085 
00086     p->mObj = dkcAllocSHA256();
00087 }
00088 
00089 
00090 void WINAPI dkcSHO_SHA384Init(DKC_SECURE_HASH_OBJECT *p){
00091 
00092     p->Init = (DKC_WINAPI_PROC_F_TYPE)dkcSHA384Init;
00093     p->Load = (DKC_WINAPI_PROC_F_TYPE)dkcSHA384Load;
00094     p->Final = (DKC_WINAPI_PROC_F_TYPE)dkcSHA384Final;
00095     p->DigestStr = (DKC_WINAPI_PROC_F_TYPE)dkcSHA384DigestStr;
00096     p->Digest = (DKC_WINAPI_PROC_F_TYPE)dkcSHA384Digest;
00097 
00098     p->digest_string_size = SHA384_STR_BUFFER_SIZE;
00099     p->digest_binary_size = SHA384_BIN_BUFFER_SIZE;
00100 
00101     p->mObj = dkcAllocSHA384();
00102 }
00103 
00104 
00106 void WINAPI dkcSHO_SHA512Init(DKC_SECURE_HASH_OBJECT *p){
00107 
00108     p->Init = (DKC_WINAPI_PROC_F_TYPE)dkcSHA512Init;
00109     p->Load = (DKC_WINAPI_PROC_F_TYPE)dkcSHA512Load;
00110     p->Final = (DKC_WINAPI_PROC_F_TYPE)dkcSHA512Final;
00111     p->DigestStr = (DKC_WINAPI_PROC_F_TYPE)dkcSHA512DigestStr;
00112     p->Digest = (DKC_WINAPI_PROC_F_TYPE)dkcSHA512Digest;
00113 
00114     p->digest_string_size = SHA512_STR_BUFFER_SIZE;
00115     p->digest_binary_size = SHA512_BIN_BUFFER_SIZE;
00116 
00117     p->mObj = dkcAllocSHA512();
00118 
00119 }
00120 static DKC_INLINE void check_init(){
00121     dkcmFORCE_NOT_ASSERT(sizeof(void *) != sizeof(DKC_SHA1 *));
00122 }
00123 
00124 #define check_() dkcmNOT_ASSERT(sizeof(void *) != sizeof(DKC_SHA1 *));
00125 
00126 typedef void (WINAPI *DKC_SHO_HASH_INIT_F_TYPE)(DKC_SECURE_HASH_OBJECT *);
00127 
00128 
00129 DKC_SECURE_HASH_OBJECT *WINAPI dkcAllocSHO(UINT option)
00130 {
00131     DKC_SECURE_HASH_OBJECT *p;
00132     DKC_SHO_HASH_INIT_F_TYPE init_func;
00133 
00134     check_init();
00135     p = dkcAllocate(sizeof(DKC_SECURE_HASH_OBJECT));
00136     if(NULL==p){
00137         return NULL;
00138     }
00139 
00140     {
00141         switch(option)
00142         {
00143         case edkcSH_MD2:
00144             init_func = dkcSHO_MD2Init;
00145             break;
00146         case edkcSH_MD4:
00147             init_func = dkcSHO_MD4Init;
00148             break;
00149         case edkcSH_MD5:
00150             init_func = dkcSHO_MD5Init;
00151             break;
00152         case edkcSH_SHA1:
00153             init_func = dkcSHO_SHA1Init;
00154             break;
00155         case edkcSH_SHA256:
00156             init_func = dkcSHO_SHA256Init;
00157             break;
00158         case edkcSH_SHA384:
00159             init_func = dkcSHO_SHA384Init;
00160             break;
00161         case edkcSH_SHA512:
00162             init_func = dkcSHO_SHA512Init;
00163             break;
00164         default:
00165             goto Error;
00166         }
00167     }
00168 
00169     //各ハッシュに応じた初期化
00170     init_func(p);
00171     if(NULL==p->mObj){
00172         goto Error;
00173     }
00174     p->mOption = option;
00175     //dkcAllocate()はmemset(0)
00176     //p->mInited = 0;
00177 
00178 
00179     return p;
00180 Error:
00181     dkcFreeSHO(&p);
00182     return NULL;
00183 }
00184 
00185 int WINAPI dkcFreeSHO(DKC_SECURE_HASH_OBJECT **pp)
00186 {
00187     DKC_SECURE_HASH_OBJECT *p = *pp;
00188     int option;
00189     void **obj;
00190 
00191     if(NULL==pp || NULL==p){
00192         return edk_FAILED;
00193     }
00194     option = p->mOption;
00195     obj = &(p->mObj);
00196     
00197     switch(option)
00198     {
00199     case edkcSH_MD2:
00200         dkcFreeMD2((DKC_MD2 **)obj);
00201         break;
00202     case edkcSH_MD4:
00203         dkcFreeMD4((DKC_MD4 **)obj);
00204         break;
00205     case edkcSH_MD5:
00206         dkcFreeMD5((DKC_MD5 **)obj);
00207         break;
00208     case edkcSH_SHA1:
00209         dkcFreeSHA1((DKC_SHA1 **)obj);
00210         break;
00211     case edkcSH_SHA256:
00212         dkcFreeSHA256((DKC_SHA256 **)obj);
00213         break;
00214     case edkcSH_SHA384:
00215         dkcFreeSHA384((DKC_SHA384 **)obj);
00216         break;
00217     case edkcSH_SHA512:
00218         dkcFreeSHA512((DKC_SHA512 **)obj);
00219         break;
00220     //default:
00221 
00222         
00223     }//eos
00224     
00225     return dkcFree(pp);
00226 }
00227 
00228 void WINAPI dkcSHOInit(DKC_SECURE_HASH_OBJECT *p)
00229 {
00230     DKC_SHO_INIT_F_TYPE init = (DKC_SHO_INIT_F_TYPE)p->Init;
00231     init(p->mObj);
00232 
00233     p->mInited = TRUE;
00234 }
00235 
00236 void WINAPI dkcSHOLoad(DKC_SECURE_HASH_OBJECT *p,const BYTE *pBuffer,DWORD dwSize)
00237 {
00238     DKC_SHO_LOAD_F_TYPE load = (DKC_SHO_LOAD_F_TYPE)p->Load;
00239     check_();
00240     if(FALSE == p->mInited){
00241         dkcSHOInit(p);
00242     }
00243     load(p->mObj,pBuffer,dwSize);
00244 }
00245 
00246 
00247 
00248 void WINAPI dkcSHOFinal(DKC_SECURE_HASH_OBJECT *p){
00249     DKC_SHO_FINAL_F_TYPE final = (DKC_SHO_FINAL_F_TYPE)p->Final;
00250     check_();
00251     final(p->mObj);
00252 }
00253 
00254 int WINAPI dkcSHODigestStr(DKC_SECURE_HASH_OBJECT *p,char *buff,size_t size)
00255 {
00256     DKC_SHO_DIGESTSTR_F_TYPE digeststr = (DKC_SHO_DIGESTSTR_F_TYPE)p->DigestStr;
00257     check_();
00258     return digeststr(p->mObj,buff,size);
00259 }
00260 
00261 
00262 int WINAPI dkcSHODigest(DKC_SECURE_HASH_OBJECT *p,BYTE *buff,size_t size)
00263 {
00264     DKC_SHO_DIGEST_F_TYPE digest = (DKC_SHO_DIGEST_F_TYPE)p->Digest;
00265     check_();
00266     return digest(p->mObj,buff,size);
00267 }
00268 
00269 
00270 
00271 
00272 static DKC_INLINE int shc(
00273     UINT hash_option,void *digest_dest,size_t destsize,
00274     const BYTE *data,size_t data_size,dkctBOOL isBinary
00275     )
00276 {
00277     int r = edk_FAILED;
00278     DKC_SECURE_HASH_OBJECT *p = dkcAllocSHO(hash_option);
00279     if(NULL==p){
00280         goto Error;
00281     }
00282 
00283     dkcSHOLoad(p,data,data_size);
00284 
00285     dkcSHOFinal(p);
00286 
00287     if(isBinary){
00288         r = dkcSHODigest(p,digest_dest,destsize);
00289     }else{//false
00290         r = dkcSHODigestStr(p,digest_dest,destsize);
00291     }
00292     if(DKUTIL_FAILED(r)){
00293         goto Error;
00294     }
00295     r = edk_SUCCEEDED;
00296 
00297 Error:
00298     dkcFreeSHO(&p);
00299     return r;
00300 }
00301 
00302 int WINAPI dkcSecureHashCalculateBinaryDigest(
00303     UINT hash_option,BYTE *digest_dest,size_t destsize,
00304     const BYTE *data,size_t data_size
00305     ){
00306 
00307     return shc(hash_option,digest_dest,destsize,data,data_size,TRUE);
00308 }
00309 
00311 int WINAPI dkcSecureHashCalculateStringDigest(
00312     UINT hash_option,char *digest_dest,size_t destsize,
00313     const BYTE *data,size_t data_size
00314 ){
00315 
00316     return shc(hash_option,digest_dest,destsize,data,data_size,FALSE);
00317 }
00318 
00319 //**********************************************************
00320 
00321 
00322 uint8 dkcHash8(uint8 *pd,size_t cycle){
00323     uint32 v = 0;
00324     size_t i;
00325     for(i=0;i<cycle;i++){
00326         v ^= (pd[i] << 3) + v;
00327     }
00328     return (uint8)((v % dkcdUNSIGNED_8BIT_PRIME_NUM) & 0xFF);
00329 }
00330 
00331 uint16 dkcHash16(uint8 *pd,size_t cycle){
00332     uint32 v = 0;
00333     size_t i;
00334     for(i=0;i<cycle;i++){
00335         v = (pd[i] << 3) + v;
00336     }
00337     return (uint16)((v % dkcdUNSIGNED_16BIT_PRIME_NUM) & 0xFFFF);
00338 }
00339 
00340 uint32 dkcHash24(uint8 *pd,size_t cycle){
00341     uint32 v = 0;
00342     size_t i;
00343     for(i=0;i<cycle;i++){
00344         v ^= (pd[i] << 3) + v;
00345     }
00346     return (v % dkcdUNSIGNED_16BIT_PRIME_NUM) & 0xFFFFFF;
00347 }

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