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

dkcSHA256.c

SHA 256 original : General Function Library Copyright (C) 2000,2001 SYN All Rights Reserved. reconstruct : d金魚. [詳細]

#include "dkcSHA256.h"
#include "dkcStdio.h"

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

Include dependency graph

ソースコードを見る。

マクロ定義

#define DKUTIL_C_SHA256_C
#define SHA256_BUFFER_SIZE   (SHA256_BLOCK * 4)

関数

DKC_INLINE DWORD ReverseEndian (DWORD x)
DKC_INLINE DWORD Rotate (DWORD x, DWORD n)
DKC_INLINE DWORD Ch (DWORD x, DWORD y, DWORD z)
DKC_INLINE DWORD Maj (DWORD x, DWORD y, DWORD z)
DKC_INLINE DWORD S0 (DWORD x)
DKC_INLINE DWORD S1 (DWORD x)
DKC_INLINE DWORD s0 (DWORD x)
DKC_INLINE DWORD s1 (DWORD x)
void Generate (DKC_SHA256 *p)
DKC_SHA256 *WINAPI dkcAllocSHA256 ()
void WINAPI dkcSHA256Init (DKC_SHA256 *p)
 dkcAllocSHA256()から取得した領域を初期化する。

void WINAPI dkcSHA256Load (DKC_SHA256 *p, const BYTE *pBuffer, DWORD dwSize)
void WINAPI dkcSHA256Final (DKC_SHA256 *p)
int WINAPI dkcSHA256DigestStr (DKC_SHA256 *p, char *buff, size_t size)
 文字列版

int WINAPI dkcSHA256FinalDigestStr (DKC_SHA256 *p, char *buff, size_t size)
int WINAPI dkcSHA256Digest (DKC_SHA256 *p, BYTE *buff, size_t size)
 バイナリ版 dkcSHA256DigestStr

int WINAPI dkcSHA256FinalDigest (DKC_SHA256 *p, BYTE *buff, size_t size)
 バイナリ版 dkcSHA256DigestStr();

int WINAPI dkcFreeSHA256 (DKC_SHA256 **p)

変数

const DWORD c_dwInitH [SHA256_HASH]
const DWORD c_dwK [SHA256_WORK]


説明

SHA 256 original : General Function Library Copyright (C) 2000,2001 SYN All Rights Reserved. reconstruct : d金魚.

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


マクロ定義

#define DKUTIL_C_SHA256_C
 

dkcSHA256.c8 行で定義されています。

#define SHA256_BUFFER_SIZE   (SHA256_BLOCK * 4)
 

dkcSHA256.c13 行で定義されています。

参照元 dkcSHA256Final(), と dkcSHA256Load().


関数

DKC_INLINE DWORD Ch DWORD  x,
DWORD  y,
DWORD  z
[static]
 

dkcSHA256.c37 行で定義されています。

参照先 DKC_INLINE, と DWORD.

00037 {return (x & (y ^ z)) ^ z;}

DKC_SHA256* WINAPI dkcAllocSHA256  ) 
 

戻り値:
DKC_SHA256構造体への確保したメモリ領域
覚え書き:
すでにdkcSHA256Init()は呼ばれています。

dkcSHA256.c69 行で定義されています。

参照先 DKC_SHA256, dkcAllocate(), dkcSHA256Init(), と NULL.

00069                                    {
00070     DKC_SHA256 *p = dkcAllocate(sizeof(DKC_SHA256));
00071     if(NULL==p){
00072         return NULL;
00073     }
00074     dkcSHA256Init(p);
00075     return p;
00076 }

int WINAPI dkcFreeSHA256 DKC_SHA256 **  p  ) 
 

引数:
p[in][out] dkcAllocSHA256()で取得したポインタへのポインタ
戻り値:
上手く開放できたらedk_SUCCEEDED

dkcSHA256.c198 行で定義されています。

参照先 DKC_SHA256, dkcFree(), edk_FAILED, と NULL.

00198                                         {
00199     if(NULL==p){
00200         return edk_FAILED;
00201     }
00202     return dkcFree((void **)p);
00203 }

int WINAPI dkcSHA256Digest DKC_SHA256 p,
BYTE buff,
size_t  size
 

バイナリ版 dkcSHA256DigestStr

dkcSHA256.c176 行で定義されています。

参照先 BYTE, DKC_SHA256, edk_BufferOverFlow, edk_LogicError, edk_SUCCEEDED, FALSE, dkc_SHA256::m_dwH, dkc_SHA256::mFinalized, と SHA256_BIN_BUFFER_SIZE.

参照元 dkcSHA256FinalDigest().

00176                                                                 {
00177     size_t i;
00178     if(SHA256_BIN_BUFFER_SIZE > size){
00179         return edk_BufferOverFlow;
00180     }
00181     if(FALSE==p->mFinalized){
00182         //まだFinalやってないっつーの
00183         return edk_LogicError;
00184     }
00185     for(i = 0; i < SHA256_BIN_BUFFER_SIZE; ++i){
00186         buff[i] = (BYTE)(p->m_dwH[i >> 2] >> (8 * (~i & 3)));
00187     }
00188     return edk_SUCCEEDED;
00189     //return dkc_memcpy(buff,size,(const void *)p->m_dwH,sizeof(p->m_dwH));
00190 }

int WINAPI dkcSHA256DigestStr DKC_SHA256 p,
char *  buff,
size_t  size
 

文字列版

引数:
p[in][out] dkcAllocSHA256()で取得したポインタ
buff[out] 書き込むバッファへのポインタ
size[in] buffのサイズ
戻り値:
成功したらedk_SUCCEEDEDが返る

dkcSHA256.c148 行で定義されています。

参照先 DKC_SHA256, dkc_strcpy(), edk_BufferOverFlow, edk_LogicError, FALSE, dkc_SHA256::m_dwH, dkc_SHA256::mFinalized, SHA256_HASH, と SHA256_STR_BUFFER_SIZE.

参照元 dkcSHA256FinalDigestStr().

00148                                                                    {
00149     //char s[SHA256_HASH * 8 + 1];
00150     char s[SHA256_STR_BUFFER_SIZE];
00151     int i;
00152 
00153     s[SHA256_HASH * 8]='\0';
00154     if(SHA256_STR_BUFFER_SIZE > size){
00155         return edk_BufferOverFlow;
00156     }
00157     if(FALSE==p->mFinalized){
00158         //まだFinalやってないっつーの
00159         return edk_LogicError;
00160     }
00161 
00162     for(i = 0; i < SHA256_HASH; i++){
00163         sprintf(s + i * 8, "%08x", p->m_dwH[i]);
00164     }
00165     //std::string strDigest = s;
00166     //return strDigest;
00167     return dkc_strcpy(buff,size,s,strlen(s));
00168 }

void WINAPI dkcSHA256Final DKC_SHA256 p  ) 
 

引数:
p[in][out] dkcAllocSHA256()で取得したポインタ
覚え書き:
dkcSHA256FinalDigest()を使用する事を奨励します。

dkcSHA256.c124 行で定義されています。

参照先 BYTE, DKC_SHA256, dkcSHA256Load(), DWORD, dkc_SHA256::m_dwHNumBits, dkc_SHA256::m_dwLNumBits, dkc_SHA256::m_nNumChr, dkc_SHA256::mFinalized, ReverseEndian(), SHA256_BUFFER_SIZE, と TRUE.

参照元 dkcSHA256FinalDigest(), と dkcSHA256FinalDigestStr().

00124                                          {
00125 
00126     BYTE cZero = 0x00;
00127     BYTE cOne  = 0x80;
00128     DWORD dwHNumBits;
00129     DWORD dwLNumBits;
00130 
00131     if(p->mFinalized){
00132         return;
00133     }
00134 
00135     dwHNumBits = ReverseEndian(p->m_dwHNumBits);
00136     dwLNumBits = ReverseEndian(p->m_dwLNumBits);
00137 
00138     dkcSHA256Load(p,&cOne, 1);
00139     while(p->m_nNumChr != SHA256_BUFFER_SIZE - 8) dkcSHA256Load(p,&cZero, 1);
00140 
00141     dkcSHA256Load(p,(BYTE *)&dwHNumBits, 4);
00142     dkcSHA256Load(p,(BYTE *)&dwLNumBits, 4);
00143 
00144     //ファイナル処理した。
00145     p->mFinalized = TRUE;
00146 }

int WINAPI dkcSHA256FinalDigest DKC_SHA256 p,
BYTE buff,
size_t  size
 

バイナリ版 dkcSHA256DigestStr();

dkcSHA256.c192 行で定義されています。

参照先 BYTE, DKC_SHA256, dkcSHA256Digest(), と dkcSHA256Final().

00192                                                                      {
00193     dkcSHA256Final(p);
00194     return dkcSHA256Digest(p,buff,size);
00195 }

int WINAPI dkcSHA256FinalDigestStr DKC_SHA256 p,
char *  buff,
size_t  size
 

参照:
引数、戻り値についてはdkcSHA256DigestStr()と同じです。
覚え書き:
dkcSHA256Final()とdkcSHA256DigestStr()を使用するより、この関数の使用を奨励します。

dkcSHA256.c169 行で定義されています。

参照先 DKC_SHA256, dkcSHA256DigestStr(), と dkcSHA256Final().

00169                                                                         {
00170     dkcSHA256Final(p);
00171     return dkcSHA256DigestStr(p,buff,size);
00172 }

void WINAPI dkcSHA256Init DKC_SHA256 p  ) 
 

dkcAllocSHA256()から取得した領域を初期化する。

dkcSHA256.c78 行で定義されています。

参照先 c_dwInitH, DKC_SHA256, FALSE, dkc_SHA256::m_dwH, dkc_SHA256::m_dwHNumBits, dkc_SHA256::m_dwLNumBits, dkc_SHA256::m_nNumChr, dkc_SHA256::mFinalized, と SHA256_HASH.

参照元 dkcAllocSHA256().

00078                                         {
00079     int i;
00080     for(i = 0; i < SHA256_HASH; i++){
00081         p->m_dwH[i] = c_dwInitH[i];
00082     }
00083     p->m_dwLNumBits = 0;
00084     p->m_dwHNumBits = 0;
00085     p->m_nNumChr = 0;
00086     p->mFinalized = FALSE;
00087 }

void WINAPI dkcSHA256Load DKC_SHA256 p,
const BYTE pBuffer,
DWORD  dwSize
 

引数:
p[in][out] dkcAllocSHA256()で取得したポインタ
pBuffer[in] 読み取るバッファへのポインタ
dwSize[in] バッファにアクセスしてOKなサイズ

dkcSHA256.c89 行で定義されています。

参照先 BYTE, DKC_SHA256, DWORD, Generate(), dkc_SHA256::m_aBlock, dkc_SHA256::m_dwHNumBits, dkc_SHA256::m_dwLNumBits, dkc_SHA256::m_nNumChr, dkc_SHA256::mFinalized, と SHA256_BUFFER_SIZE.

参照元 dkcSHA256Final().

00089                                                                          {
00090     DWORD dwReadSize;
00091     DWORD dwLNumBits;
00092     BYTE *pBlock;
00093 
00094     if(dwSize == 0) return;
00095     if(p->mFinalized){
00096         return;
00097     }
00098     dwLNumBits = (p->m_dwLNumBits + (dwSize << 3));
00099     if(dwLNumBits < p->m_dwLNumBits) p->m_dwHNumBits++;
00100     p->m_dwHNumBits += dwSize >> 29;
00101     p->m_dwLNumBits = dwLNumBits;
00102 
00103     pBlock = (BYTE *)p->m_aBlock;
00104 
00105     while(dwSize){
00106         //dwReadSize = (dwSize < SHA256_BUFFER_SIZE - p->m_nNumChr) ?
00107         dwReadSize = (dwSize < SHA256_BUFFER_SIZE - (DWORD)p->m_nNumChr) ?
00108             dwSize :
00109             (SHA256_BUFFER_SIZE - p->m_nNumChr);
00110         
00111         memcpy(pBlock + p->m_nNumChr, pBuffer, dwReadSize);
00112         
00113         p->m_nNumChr += dwReadSize;
00114         pBuffer += dwReadSize;
00115         dwSize -= dwReadSize;
00116         
00117         if(p->m_nNumChr == SHA256_BUFFER_SIZE){
00118             Generate(p);
00119             p->m_nNumChr = 0;
00120         }
00121     }
00122 }

void Generate DKC_SHA256 p  )  [static]
 

dkcSHA256.c45 行で定義されています。

参照先 c_dwK, Ch(), DKC_SHA256, DWORD, dkc_SHA256::m_aBlock, dkc_SHA256::m_dwH, Maj(), ReverseEndian(), S0(), s0(), S1(), s1(), SHA256_BLOCK, SHA256_HASH, と SHA256_WORK.

00045                                    {
00046     int i;
00047     DWORD W[SHA256_WORK];
00048     DWORD Hash[SHA256_WORK + SHA256_HASH];
00049     DWORD *pHash;
00050     DWORD dwT1, dwT2;
00051 
00052 
00053     for(i = 0; i < SHA256_BLOCK; i++) W[i] = ReverseEndian(p->m_aBlock[i]);
00054     for(i = SHA256_BLOCK; i < SHA256_WORK; i++) W[i] = s1(W[i - 2]) + W[i - 7] + s0(W[i - 15]) + W[i - 16];
00055 
00056     for(i = 0; i < SHA256_HASH; i++) Hash[SHA256_WORK + i] = p->m_dwH[i];
00057     pHash = &Hash[SHA256_WORK];
00058     
00059     for(i = 0; i < SHA256_WORK; i++){
00060         pHash--;
00061         dwT1 = pHash[8] + S1(pHash[5]) + Ch(pHash[5], pHash[6], pHash[7]) + c_dwK[i] + W[i];
00062         dwT2 = S0(pHash[1]) + Maj(pHash[1], pHash[2], pHash[3]);
00063         pHash[0] = dwT1 + dwT2;
00064         pHash[4] += dwT1;
00065     }
00066     for(i = 0; i < SHA256_HASH; i++) p->m_dwH[i] += pHash[i];
00067 }

DKC_INLINE DWORD Maj DWORD  x,
DWORD  y,
DWORD  z
[static]
 

dkcSHA256.c38 行で定義されています。

参照先 DKC_INLINE, と DWORD.

00038 {return (x & (y | z)) | (y & z);}

DKC_INLINE DWORD ReverseEndian DWORD  x  )  [static]
 

dkcSHA256.c32 行で定義されています。

参照先 DKC_INLINE, dkcReverseEndian32(), と DWORD.

参照元 dkcSHA1Final(), dkcSHA256Final(), と Generate().

00032                                                {
00033     return dkcReverseEndian32(x);
00034     //return (x << 24) | ((x & 0x0000ff00) << 8) | ((x & 0x00ff0000) >> 8) | (x >> 24);
00035 }

DKC_INLINE DWORD Rotate DWORD  x,
DWORD  n
[static]
 

dkcSHA256.c36 行で定義されています。

参照先 DKC_INLINE, と DWORD.

00036 {return (x >> n) | (x << (32 - n));}

DKC_INLINE DWORD s0 DWORD  x  )  [static]
 

dkcSHA256.c41 行で定義されています。

参照先 DKC_INLINE, DWORD, と Rotate().

00041 {return Rotate(x,  7) ^ Rotate(x, 18) ^ (x >> 3);}

DKC_INLINE DWORD S0 DWORD  x  )  [static]
 

dkcSHA256.c39 行で定義されています。

参照先 DKC_INLINE, DWORD, と Rotate().

00039 {return Rotate(x,  2) ^ Rotate(x, 13) ^ Rotate(x, 22);}

DKC_INLINE DWORD s1 DWORD  x  )  [static]
 

dkcSHA256.c42 行で定義されています。

参照先 DKC_INLINE, DWORD, と Rotate().

00042 {return Rotate(x, 17) ^ Rotate(x, 19) ^ (x >> 10);}

DKC_INLINE DWORD S1 DWORD  x  )  [static]
 

dkcSHA256.c40 行で定義されています。

参照先 DKC_INLINE, DWORD, と Rotate().

00040 {return Rotate(x,  6) ^ Rotate(x, 11) ^ Rotate(x, 25);}


変数

const DWORD c_dwInitH[SHA256_HASH] [static]
 

初期値:

 {
    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19, 
}

dkcSHA256.c16 行で定義されています。

参照元 dkcSHA256Init().

const DWORD c_dwK[SHA256_WORK] [static]
 

初期値:

 {
    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 
    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 
    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 
    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, 
    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 
    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, 
    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, 
    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2, 
}

dkcSHA256.c20 行で定義されています。

参照元 Generate().


dkutil_cに対してTue Dec 7 01:10:34 2004に生成されました。 doxygen 1.3.6