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

# dkcMD2.c

MD2 hash algorithm [詳細]

`#include "md_misc.h"`
`#include "dkcMD2.h"`
`#include "dkcStdio.h"`

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

ソースコードを見る。

## マクロ定義
#define | DKUTIL_C_MD2_C
## 関数
DKC_MD2 *WINAPI | dkcAllocMD2 ()
int WINAPI | dkcFreeMD2 (DKC_MD2 **pp)
void WINAPI | dkcMD2Init (DKC_MD2 *p)
static void | hash_init (DKC_MD2 *ptr)
static DKC_INLINE void | hash_copy (DKC_MD2 *src, DKC_MD2 *dest)
static DKC_INLINE void | hash_update (DKC_MD2 *self, const uint8 *buf, uint32 len)
static DKC_INLINE void | hash_final (DKC_MD2 *self)
static DKC_INLINE void | hash_digest (const DKC_MD2 *self, uint8 *buff)
void WINAPI | dkcMD2Load (DKC_MD2 *p, const BYTE *pBuffer, DWORD dwSize)
void WINAPI | dkcMD2Final (DKC_MD2 *p)
int WINAPI | dkcMD2Digest (DKC_MD2 *p, BYTE *buff, size_t size)
int WINAPI | dkcMD2DigestStr (DKC_MD2 *p, char *buff, size_t size)
int WINAPI | dkcMD2FinalDigestStr (DKC_MD2 *p, char *buff, size_t size)
int WINAPI | dkcMD2FinalDigest (DKC_MD2 *p, BYTE *buff, size_t size)
## 変数
static uint8 | S [256]

## 説明

MD2 hash algorithm

覚え書き:
  reconstructed by d金魚

dkcMD2.cの実装のライセンスはNYSLとします。

This is the original introductory comment:

/* md2.c : MD2 hash algorithm.

Part of the Python Cryptography Toolkit, version 1.1

Distribute and use freely; there are no restrictions on further dissemination and usage except those imposed by the laws of your country of residence.

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

## マクロ定義

#define DKUTIL_C_MD2_C

| dkcMD2.c の 22 行で定義されています。

## 関数

DKC_MD2* WINAPI dkcAllocMD2 | ( |  | ) |

| 戻り値: DKC_MD2構造体への確保したメモリ領域 覚え書き: すでにdkcMD2Init()は呼ばれています。 dkcMD2.c の 30 行で定義されています。 参照先 dkcAllocate(), dkcMD2Init(), と NULL. 参照元 dkcSHO_MD2Init().
    00030                              {
    00031     DKC_MD2 *p = dkcAllocate(sizeof(DKC_MD2));
    00032     if(NULL==p) return NULL;
    00033     dkcMD2Init(p);
    00034     return p;
    00035 }

int WINAPI dkcFreeMD2 | ( | DKC_MD2 ** | p | ) |

  | 引数:
  | p[in][out] | dkcAllocMD2()で取得したポインタへのポインタ
戻り値: 上手く開放できたらedk_SUCCEEDED dkcMD2.c の 38 行で定義されています。 参照先 dkcFree(), と NULL. 参照元 dkcFreeSHO().
    00038                                    {
    00039     if(NULL==pp || NULL==*pp){
    00040         return edk_FAILED;
    00041     }
    00042     return dkcFree((void **)pp);
    00043 }

int WINAPI dkcMD2Digest | ( | DKC_MD2 * | p,
|  | BYTE * | buff,
|  | size_t | size
| ) |

| 参照: dkcMD2DigestStr() dkcMD2.c の 170 行で定義されています。 参照先 hash_digest(), と MD2_BIN_BUFFER_SIZE. 参照元 dkcMD2DigestStr(), dkcMD2FinalDigest(), と dkcSHO_MD2Init().
    00170                                                           {
    00171
    00172     if(size < MD2_BIN_BUFFER_SIZE){
    00173         return edk_BufferOverFlow;
    00174     }
    00175     hash_digest(p,buff);
    00176     return edk_SUCCEEDED;
    00177 }

int WINAPI dkcMD2DigestStr | ( | DKC_MD2 * | p,
|  | char * | buff,
|  | size_t | size
| ) |

  | 引数:
  | p[in][out] | dkcAllocMD2()で取得したポインタ
  | buff[out] | 書き込むバッファへのポインタ
  | size[in] | buffのサイズ
戻り値: 成功したらedk_SUCCEEDEDが返る dkcMD2.c の 179 行で定義されています。 参照先 dkcMD2Digest(), MD2_BIN_BUFFER_SIZE, MD2_STR_BUFFER_SIZE, と uint8. 参照元 dkcMD2FinalDigestStr(), と dkcSHO_MD2Init().
    00179                                                              {
    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 }

void WINAPI dkcMD2Final | ( | DKC_MD2 * | p | ) |

  | 引数:
  | p[in][out] | dkcAllocMD2()で取得したポインタ
覚え書き: dkcMD2FinalDigest()を使用する事を奨励します。 dkcMD2.c の 160 行で定義されています。 参照先 edkcMD_Finalized, dkc_MD2::flags, と hash_final(). 参照元 dkcMD2FinalDigest(), dkcMD2FinalDigestStr(), と dkcSHO_MD2Init().
    00160                                    {
    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 }

int WINAPI dkcMD2FinalDigest | ( | DKC_MD2 * | p,
|  | BYTE * | buff,
|  | size_t | size
| ) |

| 参照: dkcMD2FinalDigestStr() dkcMD2.c の 201 行で定義されています。 参照先 dkcMD2Digest(), と dkcMD2Final().
    00201                                                                {
    00202     dkcMD2Final(p);
    00203     return dkcMD2Digest(p,buff,size);
    00204
    00205 }

int WINAPI dkcMD2FinalDigestStr | ( | DKC_MD2 * | p,
|  | char * | buff,
|  | size_t | size
| ) |

| 参照: 引数、戻り値についてはdkcMD2Digest()と同じです。 覚え書き: dkcMD2Final()とdkcMD2Digest()を使用するより、この関数の使用を奨励します。 dkcMD2.c の 196 行で定義されています。 参照先 dkcMD2DigestStr(), と dkcMD2Final().
    00196                                                                   {
    00197     dkcMD2Final(p);
    00198     return dkcMD2DigestStr(p,buff,size);
    00199 }

void WINAPI dkcMD2Init | ( | DKC_MD2 * |  | ) |

| 戻り値: dkcAllocMD2()から取得した領域を初期化する。 dkcMD2.c の 47 行で定義されています。 参照元 dkcAllocMD2(), dkcMD2InitEx(), と dkcSHO_MD2Init().
    00047                                   {
    00048
    00049     memset(p, 0, sizeof(*p));
    00050
    00051 }

void WINAPI dkcMD2Load | ( | DKC_MD2 * | p,
|  | const BYTE * | pBuffer,
|  | DWORD | dwSize
| ) |

  | 引数:
  | p[in][out] | dkcAllocMD2()で取得したポインタ
  | pBuffer[in] | 読み取るバッファへのポインタ
  | dwSize[in] | バッファにアクセスしてOKなサイズ
戻り値: edk_SUCCEEDEDで成功 覚え書き: ライブラリの都合により、dkcMD2Load()はINT_MAXより大きいバッファを扱えないため dkcMD2.c の 151 行で定義されています。 参照先 edkcMD_Finalized, dkc_MD2::flags, と hash_update(). 参照元 dkcSHO_MD2Init().
    00151                                                                    {
    00152     if(p->flags & edkcMD_Finalized){
    00153         return;
    00154     }
    00155     hash_update(p,pBuffer,dwSize);
    00156 }

static DKC_INLINE void hash_copy | ( | DKC_MD2 * | src,
|  | DKC_MD2 * | dest
| ) | `[static]`

| dkcMD2.c の 84 行で定義されています。 参照先 dkc_MD2::buf, dkc_MD2::C, dkc_MD2::count, と dkc_MD2::X.
    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 }

static DKC_INLINE void hash_digest | ( | const DKC_MD2 * | self,
|  | uint8 * | buff
| ) | `[static]`

| dkcMD2.c の 147 行で定義されています。 参照先 dkc_MD2::X. 参照元 dkcMD2Digest().
    00147                                                                    {
    00148     memcpy(buff,self->X, 16);
    00149 }

static DKC_INLINE void hash_final | ( | DKC_MD2 * | self | ) | `[static]`

| dkcMD2.c の 128 行で定義されています。 参照先 dkc_MD2::C, dkcmNOT_ASSERT, hash_update(), uint32, と uint8. 参照元 dkcMD2Final().
    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 }

static void hash_init | ( | DKC_MD2 * | ptr | ) | `[static]`

| dkcMD2.c の 56 行で定義されています。 参照先 dkc_MD2::C, dkc_MD2::count, と dkc_MD2::X.
    00057 {
    00058     memset(ptr->X, 0, 48);
    00059     memset(ptr->C, 0, 16);
    00060     ptr->count=0;
    00061 }

static DKC_INLINE void hash_update | ( | DKC_MD2 * | self,
|  | const uint8 * | buf,
|  | uint32 | len
| ) | `[static]`

| dkcMD2.c の 93 行で定義されています。 参照先 dkc_MD2::buf, dkc_MD2::count, S, uint32, uint8, と dkc_MD2::X. 参照元 dkcMD2Load(), と hash_final().
    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 }

## 変数

uint8 S[256]`[static]`

| 初期値:
     {
        41, 46, 67, 201, 162, 216, 124, 1, 61, 54, 84, 161, 236, 240, 6,
        19, 98, 167, 5, 243, 192, 199, 115, 140, 152, 147, 43, 217, 188,
        76, 130, 202, 30, 155, 87, 60, 253, 212, 224, 22, 103, 66, 111, 24,
        138, 23, 229, 18, 190, 78, 196, 214, 218, 158, 222, 73, 160, 251,
        245, 142, 187, 47, 238, 122, 169, 104, 121, 145, 21, 178, 7, 63,
        148, 194, 16, 137, 11, 34, 95, 33, 128, 127, 93, 154, 90, 144, 50,
        39, 53, 62, 204, 231, 191, 247, 151, 3, 255, 25, 48, 179, 72, 165,
        181, 209, 215, 94, 146, 42, 172, 86, 170, 198, 79, 184, 56, 210,
        150, 164, 125, 182, 118, 252, 107, 226, 156, 116, 4, 241, 69, 157,
        112, 89, 100, 113, 135, 32, 134, 91, 207, 101, 230, 45, 168, 2, 27,
        96, 37, 173, 174, 176, 185, 246, 28, 70, 97, 105, 52, 64, 126, 15,
        85, 71, 163, 35, 221, 81, 175, 58, 195, 92, 249, 206, 186, 197,
        234, 38, 44, 83, 13, 110, 133, 40, 132, 9, 211, 223, 205, 244, 65,
        129, 77, 82, 106, 220, 55, 200, 108, 193, 171, 250, 36, 225, 123,
        8, 12, 189, 177, 74, 120, 136, 149, 139, 227, 99, 232, 109, 233,
        203, 213, 254, 59, 0, 29, 57, 242, 239, 183, 14, 102, 88, 208, 228,
        166, 119, 114, 248, 235, 117, 75, 10, 49, 68, 80, 180, 143, 237,
        31, 26, 219, 153, 141, 51, 159, 17, 131, 20
    }
dkcMD2.c の 63 行で定義されています。