メインページ | 構成 | ファイル一覧 | 構成メンバ | ファイルメンバ | 関連ページ

dkcSHA1.c

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

#include "dkcSHA1.h"
#include "dkcStdio.h"

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

Include dependency graph

ソースコードを見る。

マクロ定義

#define SHA_BUFFER_SIZE   (SHA_BLOCK * 4)

関数

DKC_INLINE DWORD ReverseEndian (DWORD dwValue)
DKC_INLINE DWORD Rotate (DWORD dwValue, DWORD dwNum)
DKC_INLINE Generate (DKC_SHA1 *p)
DKC_SHA1 *WINAPI dkcAllocSHA1 ()
void WINAPI dkcSHA1Init (DKC_SHA1 *p)
 dkcAllocSHA1()から取得した領域を初期化する。

void WINAPI dkcSHA1Load (DKC_SHA1 *p, const BYTE *pBuffer, DWORD dwSize)
void WINAPI dkcSHA1Final (DKC_SHA1 *p)
int WINAPI dkcSHA1DigestStr (DKC_SHA1 *p, char *buff, size_t size)
int WINAPI dkcSHA1FinalDigestStr (DKC_SHA1 *p, char *buff, size_t size)
int WINAPI dkcSHA1Digest (DKC_SHA1 *p, BYTE *buff, size_t size)
 binaryハッシュ値 版 dkcSHA1DigestStr()

int WINAPI dkcSHA1FinalDigest (DKC_SHA1 *p, BYTE *buff, size_t size)
 binaryハッシュ値 版 dkcSHA1FinalDigestStr()

int WINAPI dkcFreeSHA1 (DKC_SHA1 **p)

変数

const DWORD c_dwInitH0 = 0x67452301
const DWORD c_dwInitH1 = 0xefcdab89
const DWORD c_dwInitH2 = 0x98badcfe
const DWORD c_dwInitH3 = 0x10325476
const DWORD c_dwInitH4 = 0xc3d2e1f0
const DWORD c_dwK_00_19 = 0x5a827999
const DWORD c_dwK_20_39 = 0x6ed9eba1
const DWORD c_dwK_40_59 = 0x8f1bbcdc
const DWORD c_dwK_60_79 = 0xca62c1d6


説明

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

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


マクロ定義

#define SHA_BUFFER_SIZE   (SHA_BLOCK * 4)
 

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

参照元 dkcSHA1Final(), と dkcSHA1Load().


関数

DKC_SHA1* WINAPI dkcAllocSHA1  ) 
 

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

dkcSHA1.c82 行で定義されています。

参照先 DKC_SHA1, dkcAllocate(), dkcSHA1Init(), と NULL.

参照元 dkcOpenFileWithSignature().

00082                                {
00083     DKC_SHA1 *p = dkcAllocate(sizeof(DKC_SHA1));
00084     if(NULL==p){
00085         return NULL;
00086     }
00087     dkcSHA1Init(p);
00088     return p;
00089 }

int WINAPI dkcFreeSHA1 DKC_SHA1 **  p  ) 
 

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

dkcSHA1.c225 行で定義されています。

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

参照元 dkcCloseFileWithSignature(), と dkcOpenFileWithSignature().

00225                                     {
00226     if(NULL==p){
00227         return edk_FAILED;
00228     }
00229     return dkcFree(p);
00230 }

int WINAPI dkcSHA1Digest DKC_SHA1 p,
BYTE buff,
size_t  size
 

binaryハッシュ値 版 dkcSHA1DigestStr()

dkcSHA1.c193 行で定義されています。

参照先 BYTE, DKC_SHA1, edk_BufferOverFlow, edk_LogicError, edk_SUCCEEDED, FALSE, dkc_SHA1::m_dwH, dkc_SHA1::mFinalized, と SHA1_BIN_BUFFER_SIZE.

参照元 dkcSHA1FinalDigest().

00193                                                             {
00194     size_t i = 0;
00195     //DWORD *dwp = (DWORD *)buff;
00196     //char s[SHA1_STR_BUFFER_SIZE];
00197     //s[SHA1_STR_BUFFER_SIZE]='\0';
00198 
00199     if(SHA1_BIN_BUFFER_SIZE > size){
00200         return edk_BufferOverFlow;
00201     }
00202     if(FALSE==p->mFinalized){
00203         //まだFinalやってないっつーの
00204         return edk_LogicError;
00205     }
00206     /*
00207     for( i = 0; i < SHA_HASH; i++){
00208         sprintf(s + i * 8, "%08x", p->m_dwH[i]);
00209         dwp[i] = atoi(s + i * 8);
00210     }*/
00211     for(i = 0; i < SHA1_BIN_BUFFER_SIZE; ++i){
00212         buff[i] = (BYTE)(p->m_dwH[i >> 2] >> (8 * (~i & 3)));
00213     }
00214     return edk_SUCCEEDED;
00215     //ナにバカやってんだ私。
00216     //return dkc_memcpy(buff,size,(const void *)p->m_dwH,sizeof(p->m_dwH));
00217 }

int WINAPI dkcSHA1DigestStr DKC_SHA1 p,
char *  buff,
size_t  size
 

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

dkcSHA1.c163 行で定義されています。

参照先 DKC_SHA1, dkc_strcpy(), edk_BufferOverFlow, edk_LogicError, FALSE, dkc_SHA1::m_dwH, dkc_SHA1::mFinalized, SHA1_STR_BUFFER_SIZE, と SHA_HASH.

参照元 dkcSHA1FinalDigestStr().

00163                                                                {
00164 
00165     //char s[SHA_HASH * 8 + 1];
00166     char s[SHA1_STR_BUFFER_SIZE];
00167     int i;
00168     //s[SHA_HASH * 8]='\0';
00169     s[SHA1_STR_BUFFER_SIZE]='\0';
00170 
00171     if(SHA1_STR_BUFFER_SIZE > size){
00172         return edk_BufferOverFlow;
00173     }
00174     if(FALSE==p->mFinalized){
00175         //まだFinalやってないっつーの
00176         return edk_LogicError;
00177     }
00178 
00179     for( i = 0; i < SHA_HASH; i++){
00180         sprintf(s + i * 8, "%08x", p->m_dwH[i]);
00181     }
00182     //std::string strDigest = s;
00183     //return strDigest;
00184     return dkc_strcpy(buff,size,s,strlen(s));
00185 }

void WINAPI dkcSHA1Final DKC_SHA1 p  ) 
 

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

dkcSHA1.c140 行で定義されています。

参照先 BYTE, DKC_SHA1, dkcSHA1Load(), DWORD, dkc_SHA1::m_dwHNumBits, dkc_SHA1::m_dwLNumBits, dkc_SHA1::m_nNumChr, dkc_SHA1::mFinalized, ReverseEndian(), SHA_BUFFER_SIZE, と TRUE.

参照元 dkcSHA1FinalDigest(), と dkcSHA1FinalDigestStr().

00140                                      {
00141     BYTE cZero = 0x00;
00142     BYTE cOne  = 0x80;
00143     DWORD dwHNumBits;
00144     DWORD dwLNumBits;
00145     if(p->mFinalized){
00146         return ;
00147     }
00148 
00149     dwHNumBits = ReverseEndian(p->m_dwHNumBits);
00150     dwLNumBits = ReverseEndian(p->m_dwLNumBits);
00151 
00152     dkcSHA1Load(p,&cOne, 1);
00153     while(p->m_nNumChr != SHA_BUFFER_SIZE - 8) dkcSHA1Load(p,&cZero, 1);
00154 
00155     dkcSHA1Load(p,(BYTE *)&dwHNumBits, 4);
00156     dkcSHA1Load(p,(BYTE *)&dwLNumBits, 4);
00157     
00158     //ファイナル処理した。
00159     p->mFinalized = TRUE;
00160 
00161 }

int WINAPI dkcSHA1FinalDigest DKC_SHA1 p,
BYTE buff,
size_t  size
 

binaryハッシュ値 版 dkcSHA1FinalDigestStr()

dkcSHA1.c220 行で定義されています。

参照先 BYTE, DKC_SHA1, dkcSHA1Digest(), と dkcSHA1Final().

参照元 dkcFileWithSignatureCheckCheat(), と FileWithSignatureGetDigest().

00220                                                                  {
00221     dkcSHA1Final(p);
00222     return dkcSHA1Digest(p,buff,size);
00223 }

int WINAPI dkcSHA1FinalDigestStr DKC_SHA1 p,
char *  buff,
size_t  size
 

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

dkcSHA1.c188 行で定義されています。

参照先 DKC_SHA1, dkcSHA1DigestStr(), と dkcSHA1Final().

00188                                                                     {
00189     dkcSHA1Final(p);
00190     return dkcSHA1DigestStr(p,buff,size);
00191 }

void WINAPI dkcSHA1Init DKC_SHA1 p  ) 
 

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

dkcSHA1.c91 行で定義されています。

参照先 c_dwInitH0, c_dwInitH1, c_dwInitH2, c_dwInitH3, c_dwInitH4, DKC_SHA1, FALSE, dkc_SHA1::m_dwH, dkc_SHA1::m_dwHNumBits, dkc_SHA1::m_dwLNumBits, dkc_SHA1::m_nNumChr, と dkc_SHA1::mFinalized.

参照元 dkcAllocSHA1().

00091                                     {
00092     p->m_dwH[0] = c_dwInitH0;
00093     p->m_dwH[1] = c_dwInitH1;
00094     p->m_dwH[2] = c_dwInitH2;
00095     p->m_dwH[3] = c_dwInitH3;
00096     p->m_dwH[4] = c_dwInitH4;
00097     p->m_dwLNumBits = 0;
00098     p->m_dwHNumBits = 0;
00099     p->m_nNumChr = 0;
00100 
00101     p->mFinalized = FALSE;
00102 }

void WINAPI dkcSHA1Load DKC_SHA1 p,
const BYTE pBuffer,
DWORD  dwSize
 

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

dkcSHA1.c104 行で定義されています。

参照先 BYTE, DKC_SHA1, DWORD, Generate(), dkc_SHA1::m_aBlock, dkc_SHA1::m_dwHNumBits, dkc_SHA1::m_dwLNumBits, dkc_SHA1::m_nNumChr, dkc_SHA1::mFinalized, と SHA_BUFFER_SIZE.

参照元 dkcFileWithSignatureCheckCheat(), dkcOpenFileWithSignature(), dkcSHA1Final(), FileWithSignatureGetDigest(), ReadCallback(), と WriteCallback().

00104                                                                      {
00105     DWORD dwLNumBits;
00106     BYTE *pBlock;
00107     DWORD dwReadSize;
00108     
00109     if(dwSize == 0) return;
00110     if(p->mFinalized){
00111         return;
00112     }
00113 
00114     dwLNumBits = (p->m_dwLNumBits + (dwSize << 3));
00115     if(dwLNumBits < p->m_dwLNumBits) p->m_dwHNumBits++;
00116     p->m_dwHNumBits += dwSize >> 29;
00117     p->m_dwLNumBits = dwLNumBits;
00118 
00119     pBlock = (BYTE *)p->m_aBlock;
00120     while(dwSize){
00121         //dwReadSize = (dwSize < SHA_BUFFER_SIZE - p->m_nNumChr) ?
00122         dwReadSize = (dwSize < SHA_BUFFER_SIZE - (DWORD)p->m_nNumChr) ?
00123             dwSize :
00124             (SHA_BUFFER_SIZE - p->m_nNumChr);
00125 
00126         memcpy(pBlock + p->m_nNumChr, pBuffer, dwReadSize);
00127 
00128         p->m_nNumChr += dwReadSize;
00129         pBuffer += dwReadSize;
00130         dwSize -= dwReadSize;
00131 
00132         if(p->m_nNumChr == SHA_BUFFER_SIZE){
00133             Generate(p);
00134             p->m_nNumChr = 0;
00135         }
00136     }
00137 
00138 }

DKC_INLINE Generate DKC_SHA1 p  )  [static]
 

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

参照先 c_dwK_00_19, c_dwK_20_39, c_dwK_40_59, c_dwK_60_79, DKC_INLINE, DKC_SHA1, DWORD, dkc_SHA1::m_aBlock, dkc_SHA1::m_dwH, ReverseEndian(), Rotate(), SHA_BLOCK, SHA_HASH, と SHA_WORK.

00040 {
00041     int i;
00042     DWORD Work[SHA_WORK];
00043     DWORD Hash[SHA_WORK + SHA_HASH];
00044     DWORD *pHash;
00045 
00046     for(i = 0; i < SHA_BLOCK; i++) Work[i] = ReverseEndian(p->m_aBlock[i]);
00047     for(i = SHA_BLOCK; i < SHA_WORK; i++){
00048         Work[i] = Rotate(Work[i - 3] ^ Work[i - 8] ^ Work[i - 14] ^ Work[i - 16], 1);
00049     }
00050 
00051     for(i = 0; i < 5; i++) Hash[SHA_WORK + i] = p->m_dwH[i];
00052     pHash = &Hash[SHA_WORK];
00053 
00054     for(i = 0; i < 20; i++){
00055         pHash--;
00056         pHash[0] = (pHash[2] & (pHash[3] ^ pHash[4])) ^ pHash[4];
00057         pHash[0] += Rotate(pHash[1], 5) + pHash[5] + Work[i] + c_dwK_00_19;
00058         pHash[2] = Rotate(pHash[2], 30);
00059     }
00060     for(i = 20; i < 40; i++){
00061         pHash--;
00062         pHash[0] = pHash[2] ^ pHash[3] ^ pHash[4];
00063         pHash[0] += Rotate(pHash[1], 5) + pHash[5] + Work[i] + c_dwK_20_39;
00064         pHash[2] = Rotate(pHash[2], 30);
00065     }
00066     for(i = 40; i < 60; i++){
00067         pHash--;
00068         pHash[0] = (pHash[2] & (pHash[3] | pHash[4])) | (pHash[3] & pHash[4]);
00069         pHash[0] += Rotate(pHash[1], 5) + pHash[5] + Work[i] + c_dwK_40_59;
00070         pHash[2] = Rotate(pHash[2], 30);
00071     }
00072     for(i = 60; i < 80; i++){
00073         pHash--;
00074         pHash[0] = pHash[2] ^ pHash[3] ^ pHash[4];
00075         pHash[0] += Rotate(pHash[1], 5) + pHash[5] + Work[i] + c_dwK_60_79;
00076         pHash[2] = Rotate(pHash[2], 30);
00077     }
00078 
00079     for(i = 0; i < 5; i++) p->m_dwH[i] += pHash[i];
00080 }

DKC_INLINE DWORD ReverseEndian DWORD  dwValue  )  [static]
 

dkcSHA1.c27 行で定義されています。

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

00028 {
00029     //return (dwValue << 24) | ((dwValue & 0x0000ff00) << 8) | ((dwValue & 0x00ff0000) >> 8) | (dwValue >> 24);
00030     return dkcReverseEndian32(dwValue);
00031 }

DKC_INLINE DWORD Rotate DWORD  dwValue,
DWORD  dwNum
[static]
 

dkcSHA1.c33 行で定義されています。

参照先 DKC_INLINE, と DWORD.

00034 {
00035     return (dwValue << dwNum) | (dwValue >> (32 - dwNum));
00036 }


変数

const DWORD c_dwInitH0 = 0x67452301 [static]
 

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

参照元 dkcSHA1Init().

const DWORD c_dwInitH1 = 0xefcdab89 [static]
 

dkcSHA1.c17 行で定義されています。

参照元 dkcSHA1Init().

const DWORD c_dwInitH2 = 0x98badcfe [static]
 

dkcSHA1.c18 行で定義されています。

参照元 dkcSHA1Init().

const DWORD c_dwInitH3 = 0x10325476 [static]
 

dkcSHA1.c19 行で定義されています。

参照元 dkcSHA1Init().

const DWORD c_dwInitH4 = 0xc3d2e1f0 [static]
 

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

参照元 dkcSHA1Init().

const DWORD c_dwK_00_19 = 0x5a827999 [static]
 

dkcSHA1.c22 行で定義されています。

参照元 Generate().

const DWORD c_dwK_20_39 = 0x6ed9eba1 [static]
 

dkcSHA1.c23 行で定義されています。

参照元 Generate().

const DWORD c_dwK_40_59 = 0x8f1bbcdc [static]
 

dkcSHA1.c24 行で定義されています。

参照元 Generate().

const DWORD c_dwK_60_79 = 0xca62c1d6 [static]
 

dkcSHA1.c25 行で定義されています。

参照元 Generate().


dkutil_cに対してSun Jul 18 22:46:08 2004に生成されました。 doxygen 1.3.6