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

# dkcHMAC.c

HMAC: Keyed-Hashing for Message Authentication [詳細]

`#include "dkcHMAC.h"`
`#include "dkcStdio.h"`

dkcHMAC.cのインクルード依存関係図

ソースコードを見る。

## マクロ定義
#define | dkcdHMAC_IMPL_STRING 0
## 関数
DKC_HMAC *WINAPI | dkcAllocHMAC (UINT option)
int WINAPI | dkcFreeHMAC (DKC_HMAC **pp)
void WINAPI | dkcHMACInit (DKC_HMAC *p, const BYTE *key, size_t key_length)
| DKC_HMACを初期化する。<s>別にdkcAllocHMAC()した後 即dkcHMACLoad()を呼んでも問題無い。</s>
void DKC_INLINE WINAPI | dkcHMACKeyInner (DKC_HMAC *p)
| ipadをハッシュ関数に通過させる処理
void WINAPI | dkcHMACLoad (DKC_HMAC *p, const BYTE *pBuffer, DWORD dwSize)
int WINAPI | dkcHMACFinal (DKC_HMAC *p)
int WINAPI | dkcHMACDigestStr (DKC_HMAC *p, char *buff, size_t size)
| 文字列のMessage Digestを取得する。
int WINAPI | dkcHMACDigest (DKC_HMAC *p, BYTE *buff, size_t size)
| バイナリのMessage Digestを取得する。

## 説明

HMAC: Keyed-Hashing for Message Authentication

作者:
  d金魚

dkcHMAC.c で定義されています。

## マクロ定義

#define dkcdHMAC_IMPL_STRING 0

| dkcHMAC.c の 13 行で定義されています。

## 関数

DKC_HMAC* WINAPI dkcAllocHMAC | ( | UINT | option | ) |

  | 引数:
  | option[in] | edk_SecureHashを使用
dkcHMAC.c の 97 行で定義されています。 参照先 dkc_SecureHashObject::digest_binary_size, dkcAllocate(), dkcAllocSHO(), dkcFreeHMAC(), dkc_HMAC::ipad, dkc_HMAC::ipad_init, NULL, dkc_HMAC::opad, dkc_HMAC::opad_init, dkc_HMAC::pad_size, と dkc_HMAC::sho.
    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 }

int WINAPI dkcFreeHMAC | ( | DKC_HMAC ** | p | ) |

  | 引数:
  | p[in][out] | dkcAllocHMAC()で取得したポインタへのポインタ
戻り値: 上手く開放できたらedk_SUCCEEDED dkcHMAC.c の 141 行で定義されています。 参照先 dkcFree(), dkcFreeSHO(), dkc_HMAC::ipad, NULL, dkc_HMAC::opad, と dkc_HMAC::sho. 参照元 dkcAllocHMAC().
    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 }

int WINAPI dkcHMACDigest | ( | DKC_HMAC * | p,
|  | BYTE * | buff,
|  | size_t | size
| ) |

| バイナリのMessage Digestを取得する。 dkcHMAC.c の 309 行で定義されています。 参照先 dkcmASSERT, dkcSHODigest(), dkc_HMAC::mInited, と dkc_HMAC::sho.
    00310 {
    00311     dkcmASSERT(2==p->mInited);
    00312     return dkcSHODigest(p->sho,buff,size);
    00313 }

int WINAPI dkcHMACDigestStr | ( | DKC_HMAC * | p,
|  | char * | buff,
|  | size_t | size
| ) |

  | 文字列のMessage Digestを取得する。 引数:
  | p[in][out] | dkcAllocHMAC()で取得したポインタ
  | buff[out] | 書き込むバッファへのポインタ
  | size[in] | buffのサイズ
戻り値: 成功したらedk_SUCCEEDEDが返る dkcHMAC.c の 302 行で定義されています。 参照先 dkcmASSERT, dkcSHODigestStr(), dkc_HMAC::mInited, と dkc_HMAC::sho.
    00303 {
    00304     dkcmASSERT(2==p->mInited);
    00305     return dkcSHODigestStr(p->sho,buff,size);
    00306 }

int WINAPI dkcHMACFinal | ( | DKC_HMAC * | p | ) |

  | 引数:
  | p[in][out] | dkcAllocHMAC()で取得したポインタ
覚え書き: dkcHMACFinalDigest()を使用する事を奨励します。 dkcHMAC.c の 255 行で定義されています。 参照先 BYTE, dkcHMACKeyInner(), dkcmNOT_ASSERT, dkcSHODigest(), dkcSHODigestStr(), dkcSHOFinal(), dkcSHOInit(), dkcSHOLoad(), FALSE, dkc_HMAC::mInited, dkc_HMAC::mInnerHashKeyed, NULL, dkc_HMAC::opad, dkc_HMAC::pad_size, と dkc_HMAC::sho.
    00255                                     {
    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 }

void WINAPI dkcHMACInit | ( | DKC_HMAC * | p,
|  | const BYTE * | key,
|  | size_t | key_length
| ) |

  | DKC_HMACを初期化する。<s>別にdkcAllocHMAC()した後 即dkcHMACLoad()を呼んでも問題無い。</s> 引数:
  | p[in][out] | dkcAllocHMAC()で取得したポインタ
dkcHMAC.c の 160 行で定義されています。 参照先 BYTE, dkc_SecureHashObject::digest_binary_size, dkc_SecureHashObject::digest_string_size, dkcmASSERT, dkcSecureHashCalculateBinaryDigest(), dkcSecureHashCalculateStringDigest(), dkcSHOInit(), FALSE, dkc_HMAC::ipad, dkc_HMAC::ipad_init, dkc_HMAC::mInited, dkc_HMAC::mInnerHashKeyed, dkc_SecureHashObject::mOption, dkc_HMAC::opad, dkc_HMAC::opad_init, dkc_HMAC::pad_size, dkc_HMAC::sho, と TRUE.
    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 }

void DKC_INLINE WINAPI dkcHMACKeyInner | ( | DKC_HMAC * | p | ) |

| ipadをハッシュ関数に通過させる処理 dkcHMAC.c の 234 行で定義されています。 参照先 dkcmASSERT, dkcSHOLoad(), dkc_HMAC::ipad, dkc_HMAC::mInnerHashKeyed, dkc_HMAC::pad_size, dkc_HMAC::sho, と TRUE. 参照元 dkcHMACFinal(), と dkcHMACLoad().
    00235 {
    00236     dkcmASSERT(!p->mInnerHashKeyed);
    00237     dkcSHOLoad(p->sho,p->ipad,p->pad_size);
    00238
    00239     p->mInnerHashKeyed = TRUE;
    00240 }

void WINAPI dkcHMACLoad | ( | DKC_HMAC * | p,
|  | const BYTE * | pBuffer,
|  | DWORD | dwSize
| ) |

  | 引数:
  | p[in][out] | dkcAllocHMAC()で取得したポインタ
  | pBuffer[in] | 読み取るバッファへのポインタ
  | dwSize[in] | バッファにアクセスしてOKなサイズ
dkcHMAC.c の 243 行で定義されています。 参照先 dkcHMACKeyInner(), dkcmASSERT, dkcSHOLoad(), FALSE, dkc_HMAC::mInited, dkc_HMAC::mInnerHashKeyed, と dkc_HMAC::sho.
    00244 {
    00245     dkcmASSERT(1==p->mInited);
    00246
    00247     if(FALSE == p->mInnerHashKeyed){
    00248         dkcHMACKeyInner(p);
    00249     }
    00250     dkcSHOLoad(p->sho,pBuffer,dwSize);
    00251 }