#include "dkcOSIndependent.h"
dkcSHA1.hのインクルード依存関係図

このグラフは、どのファイルから直接、間接的にインクルードされているかを示しています。

構成 | |
| struct | dkc_SHA1 |
マクロ定義 | |
| #define | SHA_HASH 5 |
| #define | SHA_BLOCK 16 |
| #define | SHA_WORK 80 |
| #define | SHA1_BIN_BUFFER_SIZE (SHA_HASH * 4) |
| SHA1の生ハッシュ値(binary)に必要なバッファサイズ. | |
| #define | SHA1_STR_BUFFER_SIZE (SHA_HASH * 8 + 1) |
| SHA1のハッシュ値文字列に必要なバッファサイズ. | |
型定義 | |
| typedef dkc_SHA1 | DKC_SHA1 |
関数 | |
| DKC_EXTERN DKC_SHA1 *WINAPI | dkcAllocSHA1 () |
| DKC_EXTERN void WINAPI | dkcSHA1Init (DKC_SHA1 *) |
| dkcAllocSHA1()から取得した領域を初期化する。 | |
| DKC_EXTERN void WINAPI | dkcSHA1Load (DKC_SHA1 *p, const BYTE *pBuffer, DWORD dwSize) |
| DKC_EXTERN void WINAPI | dkcSHA1Final (DKC_SHA1 *p) |
| DKC_EXTERN int WINAPI | dkcSHA1DigestStr (DKC_SHA1 *p, char *buff, size_t size) |
| DKC_EXTERN int WINAPI | dkcSHA1Digest (DKC_SHA1 *p, BYTE *buff, size_t size) |
| binaryハッシュ値 版 dkcSHA1DigestStr() | |
| DKC_EXTERN int WINAPI | dkcSHA1FinalDigestStr (DKC_SHA1 *p, char *buff, size_t size) |
| DKC_EXTERN int WINAPI | dkcSHA1FinalDigest (DKC_SHA1 *p, BYTE *buff, size_t size) |
| binaryハッシュ値 版 dkcSHA1FinalDigestStr() | |
| DKC_EXTERN int WINAPI | dkcFreeSHA1 (DKC_SHA1 **p) |
dkcSHA1.h で定義されています。
|
|
SHA1の生ハッシュ値(binary)に必要なバッファサイズ.
参照元 dkcFileWithSignatureCheckCheat(), dkcSHA1Digest(), と dkcSHO_SHA1Init(). |
|
|
SHA1のハッシュ値文字列に必要なバッファサイズ.
参照元 dkcSHA1DigestStr(), と dkcSHO_SHA1Init(). |
|
|
参照元 Generate(). |
|
|
参照元 dkcSHA1DigestStr(), と Generate(). |
|
|
参照元 Generate(). |
|
|
|
参照先 DKC_SHA1, dkcAllocate(), dkcSHA1Init(), と NULL. 参照元 dkcOpenFileWithSignature(), と dkcSHO_SHA1Init().
00083 {
00084 DKC_SHA1 *p = (DKC_SHA1 *)dkcAllocate(sizeof(DKC_SHA1));
00085 if(NULL==p){
00086 return NULL;
00087 }
00088 dkcSHA1Init(p);
00089 return p;
00090 }
|
|
|
参照先 DKC_SHA1, dkcFree(), と NULL. 参照元 dkcCloseFileWithSignature(), dkcFreeSHO(), と dkcOpenFileWithSignature().
|
|
||||||||||||||||
|
binaryハッシュ値 版 dkcSHA1DigestStr()
参照先 BYTE, DKC_SHA1, FALSE, dkc_SHA1::m_dwH, dkc_SHA1::mFinalized, と SHA1_BIN_BUFFER_SIZE. 参照元 dkcSHA1FinalDigest(), と dkcSHO_SHA1Init().
00194 {
00195 size_t i = 0;
00196 //DWORD *dwp = (DWORD *)buff;
00197 //char s[SHA1_STR_BUFFER_SIZE];
00198 //s[SHA1_STR_BUFFER_SIZE]='\0';
00199
00200 if(SHA1_BIN_BUFFER_SIZE > size){
00201 return edk_BufferOverFlow;
00202 }
00203 if(FALSE==p->mFinalized){
00204 //まだFinalやってないっつーの
00205 return edk_LogicError;
00206 }
00207 /*
00208 for( i = 0; i < SHA_HASH; i++){
00209 sprintf(s + i * 8, "%08x", p->m_dwH[i]);
00210 dwp[i] = atoi(s + i * 8);
00211 }*/
00212 for(i = 0; i < SHA1_BIN_BUFFER_SIZE; ++i){
00213 buff[i] = (BYTE)(p->m_dwH[i >> 2] >> (8 * (~i & 3)));
00214 }
00215 return edk_SUCCEEDED;
00216 //ナにバカやってんだ私。
00217 //return dkc_memcpy(buff,size,(const void *)p->m_dwH,sizeof(p->m_dwH));
00218 }
|
|
||||||||||||||||
|
参照先 DKC_SHA1, dkc_strcpy(), FALSE, dkc_SHA1::m_dwH, dkc_SHA1::mFinalized, SHA1_STR_BUFFER_SIZE, と SHA_HASH. 参照元 dkcSHA1FinalDigestStr(), と dkcSHO_SHA1Init().
00164 {
00165
00166 //char s[SHA_HASH * 8 + 1];
00167 char s[SHA1_STR_BUFFER_SIZE];
00168 int i;
00169 //s[SHA_HASH * 8]='\0';
00170 s[SHA1_STR_BUFFER_SIZE]='\0';
00171
00172 if(SHA1_STR_BUFFER_SIZE > size){
00173 return edk_BufferOverFlow;
00174 }
00175 if(FALSE==p->mFinalized){
00176 //まだFinalやってないっつーの
00177 return edk_LogicError;
00178 }
00179
00180 for( i = 0; i < SHA_HASH; i++){
00181 sprintf(s + i * 8, "%08x", p->m_dwH[i]);
00182 }
00183 //std::string strDigest = s;
00184 //return strDigest;
00185 return dkc_strcpy(buff,size,s,strlen(s));
00186 }
|
|
|
参照先 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(), と dkcSHO_SHA1Init().
00141 {
00142 BYTE cZero = 0x00;
00143 BYTE cOne = 0x80;
00144 DWORD dwHNumBits;
00145 DWORD dwLNumBits;
00146 if(p->mFinalized){
00147 return ;
00148 }
00149
00150 dwHNumBits = ReverseEndian(p->m_dwHNumBits);
00151 dwLNumBits = ReverseEndian(p->m_dwLNumBits);
00152
00153 dkcSHA1Load(p,&cOne, 1);
00154 while(p->m_nNumChr != SHA_BUFFER_SIZE - 8) dkcSHA1Load(p,&cZero, 1);
00155
00156 dkcSHA1Load(p,(BYTE *)&dwHNumBits, 4);
00157 dkcSHA1Load(p,(BYTE *)&dwLNumBits, 4);
00158
00159 //ファイナル処理した。
00160 p->mFinalized = TRUE;
00161
00162 }
|
|
||||||||||||||||
|
binaryハッシュ値 版 dkcSHA1FinalDigestStr()
参照先 BYTE, DKC_SHA1, dkcSHA1Digest(), と dkcSHA1Final(). 参照元 dkcFileWithSignatureCheckCheat(), と FileWithSignatureGetDigest().
00221 {
00222 dkcSHA1Final(p);
00223 return dkcSHA1Digest(p,buff,size);
00224 }
|
|
||||||||||||||||
|
参照先 DKC_SHA1, dkcSHA1DigestStr(), と dkcSHA1Final().
00189 {
00190 dkcSHA1Final(p);
00191 return dkcSHA1DigestStr(p,buff,size);
00192 }
|
|
|
dkcAllocSHA1()から取得した領域を初期化する。
参照先 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(), と dkcSHO_SHA1Init().
00092 {
00093 p->m_dwH[0] = c_dwInitH0;
00094 p->m_dwH[1] = c_dwInitH1;
00095 p->m_dwH[2] = c_dwInitH2;
00096 p->m_dwH[3] = c_dwInitH3;
00097 p->m_dwH[4] = c_dwInitH4;
00098 p->m_dwLNumBits = 0;
00099 p->m_dwHNumBits = 0;
00100 p->m_nNumChr = 0;
00101
00102 p->mFinalized = FALSE;
00103 }
|
|
||||||||||||||||
|
参照先 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(), dkcSHO_SHA1Init(), FileWithSignatureGetDigest(), ReadCallback(), と WriteCallback().
00105 {
00106 DWORD dwLNumBits;
00107 BYTE *pBlock;
00108 DWORD dwReadSize;
00109
00110 if(dwSize == 0) return;
00111 if(p->mFinalized){
00112 return;
00113 }
00114
00115 dwLNumBits = (p->m_dwLNumBits + (dwSize << 3));
00116 if(dwLNumBits < p->m_dwLNumBits) p->m_dwHNumBits++;
00117 p->m_dwHNumBits += dwSize >> 29;
00118 p->m_dwLNumBits = dwLNumBits;
00119
00120 pBlock = (BYTE *)p->m_aBlock;
00121 while(dwSize){
00122 //dwReadSize = (dwSize < SHA_BUFFER_SIZE - p->m_nNumChr) ?
00123 dwReadSize = (dwSize < SHA_BUFFER_SIZE - (DWORD)p->m_nNumChr) ?
00124 dwSize :
00125 (SHA_BUFFER_SIZE - p->m_nNumChr);
00126
00127 memcpy(pBlock + p->m_nNumChr, pBuffer, dwReadSize);
00128
00129 p->m_nNumChr += dwReadSize;
00130 pBuffer += dwReadSize;
00131 dwSize -= dwReadSize;
00132
00133 if(p->m_nNumChr == SHA_BUFFER_SIZE){
00134 Generate(p);
00135 p->m_nNumChr = 0;
00136 }
00137 }
00138
00139 }
|
1.3.6