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

マクロ定義 | |
| #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 |
dkcSHA1.c で定義されています。
|
|
参照元 dkcSHA1Final(), と dkcSHA1Load(). |
|
|
参照先 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 }
|
|
|
参照先 DKC_SHA1, dkcFree(), edk_FAILED, と NULL. 参照元 dkcCloseFileWithSignature(), と dkcOpenFileWithSignature().
00225 {
00226 if(NULL==p){
00227 return edk_FAILED;
00228 }
00229 return dkcFree(p);
00230 } |
|
||||||||||||||||
|
binaryハッシュ値 版 dkcSHA1DigestStr()
参照先 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 }
|
|
||||||||||||||||
|
参照先 DKC_SHA1, dkc_strcpy(), edk_BufferOverFlow, edk_LogicError, FALSE, dkc_SHA1::m_dwH, dkc_SHA1::mFinalized, SHA1_STR_BUFFER_SIZE, と SHA_HASH.
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 }
|
|
|
参照先 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 }
|
|
||||||||||||||||
|
binaryハッシュ値 版 dkcSHA1FinalDigestStr()
参照先 BYTE, DKC_SHA1, dkcSHA1Digest(), と dkcSHA1Final(). 参照元 dkcFileWithSignatureCheckCheat(), と FileWithSignatureGetDigest().
00220 {
00221 dkcSHA1Final(p);
00222 return dkcSHA1Digest(p,buff,size);
00223 }
|
|
||||||||||||||||
|
参照先 DKC_SHA1, dkcSHA1DigestStr(), と dkcSHA1Final().
00188 {
00189 dkcSHA1Final(p);
00190 return dkcSHA1DigestStr(p,buff,size);
00191 }
|
|
|
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().
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 }
|
|
||||||||||||||||
|
参照先 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 }
|
|
|
参照先 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, dkcReverseEndian32(), と DWORD.
00028 {
00029 //return (dwValue << 24) | ((dwValue & 0x0000ff00) << 8) | ((dwValue & 0x00ff0000) >> 8) | (dwValue >> 24);
00030 return dkcReverseEndian32(dwValue);
00031 }
|
|
||||||||||||
|
参照先 DKC_INLINE, と DWORD.
00034 {
00035 return (dwValue << dwNum) | (dwValue >> (32 - dwNum));
00036 }
|
|
|
参照元 dkcSHA1Init(). |
|
|
参照元 dkcSHA1Init(). |
|
|
参照元 dkcSHA1Init(). |
|
|
参照元 dkcSHA1Init(). |
|
|
参照元 dkcSHA1Init(). |
|
|
参照元 Generate(). |
|
|
参照元 Generate(). |
|
|
参照元 Generate(). |
|
|
参照元 Generate(). |
1.3.6