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

dkcSHA1.c

説明を見る。
00001 
00009 #define DKUTIL_C_SHA1_C
00010 #include "dkcSHA1.h"
00011 #include "dkcStdio.h"
00012 
00013 
00014 #define SHA_BUFFER_SIZE (SHA_BLOCK * 4)
00015 
00016 
00017 const static DWORD c_dwInitH0 = 0x67452301;
00018 const static DWORD c_dwInitH1 = 0xefcdab89;
00019 const static DWORD c_dwInitH2 = 0x98badcfe;
00020 const static DWORD c_dwInitH3 = 0x10325476;
00021 const static DWORD c_dwInitH4 = 0xc3d2e1f0;
00022 
00023 const static DWORD c_dwK_00_19 = 0x5a827999;
00024 const static DWORD c_dwK_20_39 = 0x6ed9eba1;
00025 const static DWORD c_dwK_40_59 = 0x8f1bbcdc;
00026 const static DWORD c_dwK_60_79 = 0xca62c1d6;
00027 
00028 static DKC_INLINE DWORD ReverseEndian(DWORD dwValue)
00029 {
00030     //return (dwValue << 24) | ((dwValue & 0x0000ff00) << 8) | ((dwValue & 0x00ff0000) >> 8) | (dwValue >> 24);
00031     return dkcReverseEndian32(dwValue);
00032 }
00033 
00034 static DKC_INLINE DWORD Rotate(DWORD dwValue, DWORD dwNum)
00035 {
00036     return (dwValue << dwNum) | (dwValue >> (32 - dwNum));
00037 }
00038 
00039 
00040 static DKC_INLINE Generate(DKC_SHA1 *p)
00041 {
00042     int i;
00043     DWORD Work[SHA_WORK];
00044     DWORD Hash[SHA_WORK + SHA_HASH];
00045     DWORD *pHash;
00046 
00047     for(i = 0; i < SHA_BLOCK; i++) Work[i] = ReverseEndian(p->m_aBlock[i]);
00048     for(i = SHA_BLOCK; i < SHA_WORK; i++){
00049         Work[i] = Rotate(Work[i - 3] ^ Work[i - 8] ^ Work[i - 14] ^ Work[i - 16], 1);
00050     }
00051 
00052     for(i = 0; i < 5; i++) Hash[SHA_WORK + i] = p->m_dwH[i];
00053     pHash = &Hash[SHA_WORK];
00054 
00055     for(i = 0; i < 20; i++){
00056         pHash--;
00057         pHash[0] = (pHash[2] & (pHash[3] ^ pHash[4])) ^ pHash[4];
00058         pHash[0] += Rotate(pHash[1], 5) + pHash[5] + Work[i] + c_dwK_00_19;
00059         pHash[2] = Rotate(pHash[2], 30);
00060     }
00061     for(i = 20; i < 40; i++){
00062         pHash--;
00063         pHash[0] = pHash[2] ^ pHash[3] ^ pHash[4];
00064         pHash[0] += Rotate(pHash[1], 5) + pHash[5] + Work[i] + c_dwK_20_39;
00065         pHash[2] = Rotate(pHash[2], 30);
00066     }
00067     for(i = 40; i < 60; i++){
00068         pHash--;
00069         pHash[0] = (pHash[2] & (pHash[3] | pHash[4])) | (pHash[3] & pHash[4]);
00070         pHash[0] += Rotate(pHash[1], 5) + pHash[5] + Work[i] + c_dwK_40_59;
00071         pHash[2] = Rotate(pHash[2], 30);
00072     }
00073     for(i = 60; i < 80; i++){
00074         pHash--;
00075         pHash[0] = pHash[2] ^ pHash[3] ^ pHash[4];
00076         pHash[0] += Rotate(pHash[1], 5) + pHash[5] + Work[i] + c_dwK_60_79;
00077         pHash[2] = Rotate(pHash[2], 30);
00078     }
00079 
00080     for(i = 0; i < 5; i++) p->m_dwH[i] += pHash[i];
00081 }
00082 
00083 DKC_SHA1 *WINAPI dkcAllocSHA1(){
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 }
00091 
00092 void WINAPI dkcSHA1Init(DKC_SHA1 *p){
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 }
00104 
00105 void WINAPI dkcSHA1Load(DKC_SHA1 *p,const BYTE *pBuffer,DWORD dwSize){
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 }
00140 
00141 void WINAPI dkcSHA1Final(DKC_SHA1 *p){
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 }
00163 
00164 int WINAPI dkcSHA1DigestStr(DKC_SHA1 *p,char *buff,size_t size){
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 }
00187 
00188 
00189 int WINAPI dkcSHA1FinalDigestStr(DKC_SHA1 *p,char *buff,size_t size){
00190     dkcSHA1Final(p);
00191     return dkcSHA1DigestStr(p,buff,size);
00192 }
00193 
00194 int WINAPI dkcSHA1Digest(DKC_SHA1 *p,BYTE *buff,size_t size){
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 }
00219 
00220 
00221 int WINAPI dkcSHA1FinalDigest(DKC_SHA1 *p,BYTE *buff,size_t size){
00222     dkcSHA1Final(p);
00223     return dkcSHA1Digest(p,buff,size);
00224 }
00225 
00226 int WINAPI dkcFreeSHA1(DKC_SHA1 **p){
00227     if(NULL==p){
00228         return edk_FAILED;
00229     }
00230     return dkcFree((void **)p);
00231 }

dkutil_cに対してTue Feb 22 02:01:48 2005に生成されました。 doxygen 1.3.6