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

# dkcHMAC.c

説明を見る。

    00001
    00009 #include "dkcHMAC.h"
    00010 #include "dkcStdio.h"
    00011
    00012
    00013 #define dkcdHMAC_IMPL_STRING 0
    00014
    00015 /*
    00016 void WINAPI dkcHMAC_MD5Init(DKC_HMAC *p){
    00017
    00018
    00019     p->Init = (DKC_WINAPI_PROC_F_TYPE)dkcMD5Init;
    00020     p->Load = (DKC_WINAPI_PROC_F_TYPE)dkcMD5Load;
    00021     p->Final = (DKC_WINAPI_PROC_F_TYPE)dkcMD5Final;
    00022     p->DigestStr = (DKC_WINAPI_PROC_F_TYPE)dkcMD5DigestStr;
    00023     p->Digest = (DKC_WINAPI_PROC_F_TYPE)dkcMD5Digest;
    00024     p->ipad_init = 0x36;
    00025     p->opad_init = 0x5c;
    00026     p->digest_string_size = MD5_STR_BUFFER_SIZE;
    00027     p->digest_binary_size = MD5_BIN_BUFFER_SIZE;
    00028
    00029     p->mObj = dkcAllocMD5();
    00030 }
    00031
    00032
    00033 void WINAPI dkcHMAC_SHA1Init(DKC_HMAC *p){
    00034
    00035     p->Init = (DKC_WINAPI_PROC_F_TYPE)dkcSHA1Init;
    00036     p->Load = (DKC_WINAPI_PROC_F_TYPE)dkcSHA1Load;
    00037     p->Final = (DKC_WINAPI_PROC_F_TYPE)dkcSHA1Final;
    00038     p->DigestStr = (DKC_WINAPI_PROC_F_TYPE)dkcSHA1DigestStr;
    00039     p->Digest = (DKC_WINAPI_PROC_F_TYPE)dkcSHA1Digest;
    00040     p->ipad_init = 0x36;
    00041     p->opad_init = 0x5c;
    00042     p->digest_string_size = SHA1_STR_BUFFER_SIZE;
    00043     p->digest_binary_size = SHA1_BIN_BUFFER_SIZE;
    00044
    00045     p->mObj = dkcAllocSHA1();
    00046 }
    00047
    00048
    00049 void WINAPI dkcHMAC_SHA256Init(DKC_HMAC *p){
    00050
    00051     p->Init = (DKC_WINAPI_PROC_F_TYPE)dkcSHA256Init;
    00052     p->Load = (DKC_WINAPI_PROC_F_TYPE)dkcSHA256Load;
    00053     p->Final = (DKC_WINAPI_PROC_F_TYPE)dkcSHA256Final;
    00054     p->DigestStr = (DKC_WINAPI_PROC_F_TYPE)dkcSHA256DigestStr;
    00055     p->Digest = (DKC_WINAPI_PROC_F_TYPE)dkcSHA256Digest;
    00056     p->ipad_init = 0x36;
    00057     p->opad_init = 0x5c;
    00058     p->digest_string_size = SHA256_STR_BUFFER_SIZE;
    00059     p->digest_binary_size = SHA256_BIN_BUFFER_SIZE;
    00060
    00061     p->mObj = dkcAllocSHA256();
    00062 }
    00063
    00064
    00065 void WINAPI dkcHMAC_SHA384Init(DKC_HMAC *p){
    00066
    00067     p->Init = (DKC_WINAPI_PROC_F_TYPE)dkcSHA384Init;
    00068     p->Load = (DKC_WINAPI_PROC_F_TYPE)dkcSHA384Load;
    00069     p->Final = (DKC_WINAPI_PROC_F_TYPE)dkcSHA384Final;
    00070     p->DigestStr = (DKC_WINAPI_PROC_F_TYPE)dkcSHA384DigestStr;
    00071     p->Digest = (DKC_WINAPI_PROC_F_TYPE)dkcSHA384Digest;
    00072
    00073     p->digest_string_size = SHA384_STR_BUFFER_SIZE;
    00074     p->digest_binary_size = SHA384_BIN_BUFFER_SIZE;
    00075
    00076     p->mObj = dkcAllocSHA384();
    00077 }
    00078
    00079
    00081 void WINAPI dkcHMAC_SHA512Init(DKC_HMAC *p){
    00082
    00083     p->Init = (DKC_WINAPI_PROC_F_TYPE)dkcSHA512Init;
    00084     p->Load = (DKC_WINAPI_PROC_F_TYPE)dkcSHA512Load;
    00085     p->Final = (DKC_WINAPI_PROC_F_TYPE)dkcSHA512Final;
    00086     p->DigestStr = (DKC_WINAPI_PROC_F_TYPE)dkcSHA512DigestStr;
    00087     p->Digest = (DKC_WINAPI_PROC_F_TYPE)dkcSHA512Digest;
    00088     p->ipad_init = 0x36;
    00089     p->opad_init = 0x5c;
    00090     p->digest_string_size = SHA512_STR_BUFFER_SIZE;
    00091     p->digest_binary_size = SHA512_BIN_BUFFER_SIZE;
    00092
    00093     p->mObj = dkcAllocSHA512();
    00094
    00095 }
    00096 */
    00097 DKC_HMAC *WINAPI dkcAllocHMAC(UINT option)
    00098 {
    00099     DKC_HMAC *p;
    00100
    00101     size_t padsize ;
    00102
    00103     //check_init();
    00104
    00105     p = dkcAllocate(sizeof(DKC_HMAC));
    00106     if(NULL==p){
    00107         return NULL;
    00108     }
    00109
    00110     p->sho = dkcAllocSHO(option);
    00111     if(NULL==p->sho){
    00112         goto Error;
    00113     }
    00114
    00115
    00116
    00117     //初期化した値から必要なパッドを確保
    00118     p->pad_size = p->sho->digest_binary_size * 4;
    00119
    00120     padsize = p->pad_size + 1;// + 1は文字列なので･･･
    00121
    00122     p->ipad_init = 0x36;
    00123     p->opad_init = 0x5c;
    00124
    00125     p->ipad = malloc(   padsize );
    00126     if(NULL==p->ipad){
    00127         goto Error;
    00128     }
    00129     p->opad = malloc( padsize );
    00130     if(NULL==p->opad){
    00131         goto Error;
    00132     }
    00133
    00134
    00135     return p;
    00136 Error:
    00137     dkcFreeHMAC(&p);
    00138     return NULL;
    00139 }
    00140
    00141 int WINAPI dkcFreeHMAC(DKC_HMAC **pp)
    00142 {
    00143     DKC_HMAC *p = *pp;
    00144
    00145     if(NULL==pp || NULL==p){
    00146         return edk_FAILED;
    00147     }
    00148
    00149     dkcFreeSHO(&(p->sho));
    00150
    00151     if(p->ipad){
    00152         free(p->ipad);
    00153     }
    00154     if(p->opad){
    00155         free(p->opad);
    00156     }
    00157     return dkcFree(pp);
    00158 }
    00159
    00160 void WINAPI dkcHMACInit(DKC_HMAC *p,const BYTE *key,size_t key_length)
    00161 {
    00162
    00163     size_t padsize = p->pad_size;
    00164
    00165     if (TRUE==p->mInnerHashKeyed)
    00166     {
    00167         //中身のハッシュ値を初期化
    00168         dkcSHOInit(p->sho);
    00169         //成功＾＾ 中身はないよフラグをする。
    00170         p->mInnerHashKeyed = FALSE;
    00171     }
    00172
    00173
    00174
    00175     //パッド作り
    00176     if(key_length <= padsize)
    00177     {
    00178         memcpy(p->ipad,key,key_length);
    00179     }
    00180     else
    00181     {
    00182
    00183 #if dkcdHMAC_IMPL_STRING //文字列版
    00184         dkcSecureHashCalculateStringDigest(
    00185             p->sho->mOption,
    00186             (char *)p->ipad,p->pad_size,
    00187             key,key_length
    00188         );
    00189         //update key_length
    00190         key_length = p->sho->digest_string_size;
    00191         dkcmASSERT(key_length <= p->sho->digest_string_size);
    00192
    00193 #else //binary版
    00194     dkcSecureHashCalculateBinaryDigest(
    00195             p->sho->mOption,
    00196             p->ipad,p->pad_size,
    00197             key,key_length
    00198         );
    00199         //update key_length
    00200         key_length = p->sho->digest_binary_size;
    00201         dkcmASSERT(key_length <= p->sho->digest_binary_size);
    00202 #endif
    00203     }
    00204
    00205
    00206     dkcmASSERT(key_length <= padsize);
    00207     //バッファの埋め合わせ
    00208     memset(p->ipad + key_length, 0, padsize - key_length);
    00209
    00210     //pad初期化
    00211     {
    00212         BYTE *ipad,*opad,iv,ov;
    00213         size_t i;
    00214
    00215         ipad = p->ipad;
    00216         opad = p->opad;
    00217         iv = p->ipad_init;
    00218         ov = p->opad_init;
    00219
    00220         for (i=0; i<padsize; i++)
    00221         {
    00222
    00223             opad[i] = (BYTE)(ipad[i] ^ ov);
    00224             ipad[i] ^= iv;
    00225         }
    00226
    00227     }
    00228
    00229     p->mInited = 1;
    00230
    00231 }
    00232
    00234 void DKC_INLINE WINAPI dkcHMACKeyInner(DKC_HMAC *p)
    00235 {
    00236     dkcmASSERT(!p->mInnerHashKeyed);
    00237     dkcSHOLoad(p->sho,p->ipad,p->pad_size);
    00238
    00239     p->mInnerHashKeyed = TRUE;
    00240 }
    00241
    00242
    00243 void WINAPI dkcHMACLoad(DKC_HMAC *p,const BYTE *pBuffer,DWORD dwSize)
    00244 {
    00245     dkcmASSERT(1==p->mInited);
    00246
    00247     if(FALSE == p->mInnerHashKeyed){
    00248         dkcHMACKeyInner(p);
    00249     }
    00250     dkcSHOLoad(p->sho,pBuffer,dwSize);
    00251 }
    00252
    00253
    00254
    00255 int WINAPI dkcHMACFinal(DKC_HMAC *p){
    00256     //ThrowIfInvalidTruncatedSize(size);
    00257
    00258 #if dkcdHMAC_IMPL_STRING
    00259
    00260     size_t tempsize = p->pad_size;
    00261     char *temp = malloc(tempsize);
    00262
    00263 #else
    00264     size_t tempsize = p->pad_size / 4;
    00265     char *temp = malloc(tempsize);
    00266
    00267 #endif
    00268     DKC_SECURE_HASH_OBJECT *pt = p->sho;
    00269     dkcmNOT_ASSERT(FALSE==p->mInited);
    00270
    00271     if(NULL==temp){
    00272         return edk_FAILED;
    00273     }
    00274     if(FALSE == p->mInnerHashKeyed){
    00275         dkcHMACKeyInner(p);
    00276     }
    00277
    00278     //End of inner process
    00279     dkcSHOFinal(pt);
    00280 #if dkcdHMAC_IMPL_STRING
    00281     dkcSHODigestStr(pt,temp,tempsize);
    00282 #else
    00283     dkcSHODigest(pt,(BYTE *)temp,tempsize);
    00284 #endif
    00285
    00286     //begin outer process
    00287     dkcSHOInit(pt);
    00288     dkcSHOLoad(pt,p->opad,p->pad_size);
    00289     dkcSHOLoad(pt,(const BYTE *)temp,tempsize);
    00290
    00291     dkcSHOFinal(pt);
    00292
    00293     //ココバグっているかも？
    00294     //p->mInnerHashKeyed = FALSE;
    00295     //state を 2にする
    00296     p->mInited = 2;
    00297
    00298     free(temp);
    00299     return edk_SUCCEEDED;
    00300 }
    00301
    00302 int WINAPI dkcHMACDigestStr(DKC_HMAC *p,char *buff,size_t size)
    00303 {
    00304     dkcmASSERT(2==p->mInited);
    00305     return dkcSHODigestStr(p->sho,buff,size);
    00306 }
    00307
    00308
    00309 int WINAPI dkcHMACDigest(DKC_HMAC *p,BYTE *buff,size_t size)
    00310 {
    00311     dkcmASSERT(2==p->mInited);
    00312     return dkcSHODigest(p->sho,buff,size);
    00313 }
    00314
    00315
    00316
    00317
    00318 int WINAPI dkcHMACStr(DKC_HMAC *p,const BYTE *data,size_t data_size,const BYTE *key,size_t key_size,
    00319                          char *str_result_buff,size_t buffsize)
    00320 {
    00321     int r;
    00322
    00323     dkcHMACInit(p,key,key_size);
    00324     dkcHMACLoad(p,data,data_size);
    00325     r = dkcHMACFinal(p);
    00326     if(DKUTIL_FAILED(r)) return r;
    00327     r = dkcHMACDigestStr(p,str_result_buff,buffsize);
    00328     //if(DKUTIL_FAILED(r)) return r;
    00329     return r;
    00330 }
    00331 int WINAPI dkcHMAC(DKC_HMAC *p,const BYTE *data,size_t data_size,const BYTE *key,size_t key_size,
    00332                          BYTE *bin_result_buff,size_t buffsize)
    00333 {
    00334     int r;
    00335
    00336     dkcHMACInit(p,key,key_size);
    00337     dkcHMACLoad(p,data,data_size);
    00338     r = dkcHMACFinal(p);
    00339     if(DKUTIL_FAILED(r)) return r;
    00340     r = dkcHMACDigest(p,bin_result_buff,buffsize);
    00341     //if(DKUTIL_FAILED(r)) return r;
    00342     return r;
    00343 }
    00344
    00345 int WINAPI dkcHMACCalculateBinaryDigest(
    00346     UINT hash_option,BYTE *digest_dest,size_t destsize,
    00347     const BYTE *data,size_t data_size,const BYTE *key,size_t keysize
    00348 ){
    00349     int r;
    00350     DKC_HMAC *p = dkcAllocHMAC(hash_option);
    00351     if(NULL==p) return edk_FAILED;
    00352     r = dkcHMAC(p,data,data_size,key,keysize,digest_dest,destsize);
    00353     dkcFreeHMAC(&p);
    00354     return r;
    00355
    00356
    00357 }
    00358
    00359 int WINAPI dkcHMACHashCalculateStringDigest(
    00360     UINT hash_option,char *digest_dest,size_t destsize,
    00361     const BYTE *data,size_t data_size,const BYTE *key,size_t keysize
    00362     ){
    00363     int r;
    00364     DKC_HMAC *p = dkcAllocHMAC(hash_option);
    00365     if(NULL==p) return edk_FAILED;
    00366     r = dkcHMACStr(p,data,data_size,key,keysize,digest_dest,destsize);
    00367     dkcFreeHMAC(&p);
    00368     return r;
    00369 }
    00370
    00371 int WINAPI dkcHMACFinalDigestStr(DKC_HMAC *p,char *buff,size_t size){
    00372     dkcHMACFinal(p);
    00373     return dkcHMACDigestStr(p,buff,size);
    00374 }
    00375
    00376 int WINAPI dkcHMACFinalDigest(DKC_HMAC *p,BYTE *buff,size_t size){
    00377     dkcHMACFinal(p);
    00378     return dkcHMACDigest(p,buff,size);
    00379
    00380 }