00001
00008 #include "dkcHash.h"
00009 #include "dkcStdio.h"
00010
00011
00012 void WINAPI dkcSHO_MD2Init(DKC_SECURE_HASH_OBJECT *p){
00013
00014 p->Init = (DKC_WINAPI_PROC_F_TYPE)dkcMD2Init;
00015 p->Load = (DKC_WINAPI_PROC_F_TYPE)dkcMD2Load;
00016 p->Final = (DKC_WINAPI_PROC_F_TYPE)dkcMD2Final;
00017 p->DigestStr = (DKC_WINAPI_PROC_F_TYPE)dkcMD2DigestStr;
00018 p->Digest = (DKC_WINAPI_PROC_F_TYPE)dkcMD2Digest;
00019
00020 p->digest_string_size = MD2_STR_BUFFER_SIZE;
00021 p->digest_binary_size = MD2_BIN_BUFFER_SIZE;
00022
00023 p->mObj = dkcAllocMD2();
00024
00025
00026 }
00027
00028 void WINAPI dkcSHO_MD4Init(DKC_SECURE_HASH_OBJECT *p){
00029
00030 p->Init = (DKC_WINAPI_PROC_F_TYPE)dkcMD4Init;
00031 p->Load = (DKC_WINAPI_PROC_F_TYPE)dkcMD4Load;
00032 p->Final = (DKC_WINAPI_PROC_F_TYPE)dkcMD4Final;
00033 p->DigestStr = (DKC_WINAPI_PROC_F_TYPE)dkcMD4DigestStr;
00034 p->Digest = (DKC_WINAPI_PROC_F_TYPE)dkcMD4Digest;
00035
00036 p->digest_string_size = MD4_STR_BUFFER_SIZE;
00037 p->digest_binary_size = MD4_BIN_BUFFER_SIZE;
00038
00039 p->mObj = dkcAllocMD4();
00040
00041
00042 }
00043
00044 void WINAPI dkcSHO_MD5Init(DKC_SECURE_HASH_OBJECT *p){
00045
00046
00047 p->Init = (DKC_WINAPI_PROC_F_TYPE)dkcMD5Init;
00048 p->Load = (DKC_WINAPI_PROC_F_TYPE)dkcMD5Load;
00049 p->Final = (DKC_WINAPI_PROC_F_TYPE)dkcMD5Final;
00050 p->DigestStr = (DKC_WINAPI_PROC_F_TYPE)dkcMD5DigestStr;
00051 p->Digest = (DKC_WINAPI_PROC_F_TYPE)dkcMD5Digest;
00052
00053 p->digest_string_size = MD5_STR_BUFFER_SIZE;
00054 p->digest_binary_size = MD5_BIN_BUFFER_SIZE;
00055
00056 p->mObj = dkcAllocMD5();
00057 }
00058
00059
00060 void WINAPI dkcSHO_SHA1Init(DKC_SECURE_HASH_OBJECT *p){
00061
00062 p->Init = (DKC_WINAPI_PROC_F_TYPE)dkcSHA1Init;
00063 p->Load = (DKC_WINAPI_PROC_F_TYPE)dkcSHA1Load;
00064 p->Final = (DKC_WINAPI_PROC_F_TYPE)dkcSHA1Final;
00065 p->DigestStr = (DKC_WINAPI_PROC_F_TYPE)dkcSHA1DigestStr;
00066 p->Digest = (DKC_WINAPI_PROC_F_TYPE)dkcSHA1Digest;
00067
00068 p->digest_string_size = SHA1_STR_BUFFER_SIZE;
00069 p->digest_binary_size = SHA1_BIN_BUFFER_SIZE;
00070
00071 p->mObj = dkcAllocSHA1();
00072 }
00073
00074
00075 void WINAPI dkcSHO_SHA256Init(DKC_SECURE_HASH_OBJECT *p){
00076
00077 p->Init = (DKC_WINAPI_PROC_F_TYPE)dkcSHA256Init;
00078 p->Load = (DKC_WINAPI_PROC_F_TYPE)dkcSHA256Load;
00079 p->Final = (DKC_WINAPI_PROC_F_TYPE)dkcSHA256Final;
00080 p->DigestStr = (DKC_WINAPI_PROC_F_TYPE)dkcSHA256DigestStr;
00081 p->Digest = (DKC_WINAPI_PROC_F_TYPE)dkcSHA256Digest;
00082
00083 p->digest_string_size = SHA256_STR_BUFFER_SIZE;
00084 p->digest_binary_size = SHA256_BIN_BUFFER_SIZE;
00085
00086 p->mObj = dkcAllocSHA256();
00087 }
00088
00089
00090 void WINAPI dkcSHO_SHA384Init(DKC_SECURE_HASH_OBJECT *p){
00091
00092 p->Init = (DKC_WINAPI_PROC_F_TYPE)dkcSHA384Init;
00093 p->Load = (DKC_WINAPI_PROC_F_TYPE)dkcSHA384Load;
00094 p->Final = (DKC_WINAPI_PROC_F_TYPE)dkcSHA384Final;
00095 p->DigestStr = (DKC_WINAPI_PROC_F_TYPE)dkcSHA384DigestStr;
00096 p->Digest = (DKC_WINAPI_PROC_F_TYPE)dkcSHA384Digest;
00097
00098 p->digest_string_size = SHA384_STR_BUFFER_SIZE;
00099 p->digest_binary_size = SHA384_BIN_BUFFER_SIZE;
00100
00101 p->mObj = dkcAllocSHA384();
00102 }
00103
00104
00106 void WINAPI dkcSHO_SHA512Init(DKC_SECURE_HASH_OBJECT *p){
00107
00108 p->Init = (DKC_WINAPI_PROC_F_TYPE)dkcSHA512Init;
00109 p->Load = (DKC_WINAPI_PROC_F_TYPE)dkcSHA512Load;
00110 p->Final = (DKC_WINAPI_PROC_F_TYPE)dkcSHA512Final;
00111 p->DigestStr = (DKC_WINAPI_PROC_F_TYPE)dkcSHA512DigestStr;
00112 p->Digest = (DKC_WINAPI_PROC_F_TYPE)dkcSHA512Digest;
00113
00114 p->digest_string_size = SHA512_STR_BUFFER_SIZE;
00115 p->digest_binary_size = SHA512_BIN_BUFFER_SIZE;
00116
00117 p->mObj = dkcAllocSHA512();
00118
00119 }
00120 static DKC_INLINE void check_init(){
00121 dkcmFORCE_NOT_ASSERT(sizeof(void *) != sizeof(DKC_SHA1 *));
00122 }
00123
00124 #define check_() dkcmNOT_ASSERT(sizeof(void *) != sizeof(DKC_SHA1 *));
00125
00126 typedef void (WINAPI *DKC_SHO_HASH_INIT_F_TYPE)(DKC_SECURE_HASH_OBJECT *);
00127
00128
00129 DKC_SECURE_HASH_OBJECT *WINAPI dkcAllocSHO(UINT option)
00130 {
00131 DKC_SECURE_HASH_OBJECT *p;
00132 DKC_SHO_HASH_INIT_F_TYPE init_func;
00133
00134 check_init();
00135 p = dkcAllocate(sizeof(DKC_SECURE_HASH_OBJECT));
00136 if(NULL==p){
00137 return NULL;
00138 }
00139
00140 {
00141 switch(option)
00142 {
00143 case edkcSH_MD2:
00144 init_func = dkcSHO_MD2Init;
00145 break;
00146 case edkcSH_MD4:
00147 init_func = dkcSHO_MD4Init;
00148 break;
00149 case edkcSH_MD5:
00150 init_func = dkcSHO_MD5Init;
00151 break;
00152 case edkcSH_SHA1:
00153 init_func = dkcSHO_SHA1Init;
00154 break;
00155 case edkcSH_SHA256:
00156 init_func = dkcSHO_SHA256Init;
00157 break;
00158 case edkcSH_SHA384:
00159 init_func = dkcSHO_SHA384Init;
00160 break;
00161 case edkcSH_SHA512:
00162 init_func = dkcSHO_SHA512Init;
00163 break;
00164 default:
00165 goto Error;
00166 }
00167 }
00168
00169
00170 init_func(p);
00171 if(NULL==p->mObj){
00172 goto Error;
00173 }
00174 p->mOption = option;
00175
00176
00177
00178
00179 return p;
00180 Error:
00181 dkcFreeSHO(&p);
00182 return NULL;
00183 }
00184
00185 int WINAPI dkcFreeSHO(DKC_SECURE_HASH_OBJECT **pp)
00186 {
00187 DKC_SECURE_HASH_OBJECT *p = *pp;
00188 int option;
00189 void **obj;
00190
00191 if(NULL==pp || NULL==p){
00192 return edk_FAILED;
00193 }
00194 option = p->mOption;
00195 obj = &(p->mObj);
00196
00197 switch(option)
00198 {
00199 case edkcSH_MD2:
00200 dkcFreeMD2((DKC_MD2 **)obj);
00201 break;
00202 case edkcSH_MD4:
00203 dkcFreeMD4((DKC_MD4 **)obj);
00204 break;
00205 case edkcSH_MD5:
00206 dkcFreeMD5((DKC_MD5 **)obj);
00207 break;
00208 case edkcSH_SHA1:
00209 dkcFreeSHA1((DKC_SHA1 **)obj);
00210 break;
00211 case edkcSH_SHA256:
00212 dkcFreeSHA256((DKC_SHA256 **)obj);
00213 break;
00214 case edkcSH_SHA384:
00215 dkcFreeSHA384((DKC_SHA384 **)obj);
00216 break;
00217 case edkcSH_SHA512:
00218 dkcFreeSHA512((DKC_SHA512 **)obj);
00219 break;
00220
00221
00222
00223 }
00224
00225 return dkcFree(pp);
00226 }
00227
00228 void WINAPI dkcSHOInit(DKC_SECURE_HASH_OBJECT *p)
00229 {
00230 DKC_SHO_INIT_F_TYPE init = (DKC_SHO_INIT_F_TYPE)p->Init;
00231 init(p->mObj);
00232
00233 p->mInited = TRUE;
00234 }
00235
00236 void WINAPI dkcSHOLoad(DKC_SECURE_HASH_OBJECT *p,const BYTE *pBuffer,DWORD dwSize)
00237 {
00238 DKC_SHO_LOAD_F_TYPE load = (DKC_SHO_LOAD_F_TYPE)p->Load;
00239 check_();
00240 if(FALSE == p->mInited){
00241 dkcSHOInit(p);
00242 }
00243 load(p->mObj,pBuffer,dwSize);
00244 }
00245
00246
00247
00248 void WINAPI dkcSHOFinal(DKC_SECURE_HASH_OBJECT *p){
00249 DKC_SHO_FINAL_F_TYPE final = (DKC_SHO_FINAL_F_TYPE)p->Final;
00250 check_();
00251 final(p->mObj);
00252 }
00253
00254 int WINAPI dkcSHODigestStr(DKC_SECURE_HASH_OBJECT *p,char *buff,size_t size)
00255 {
00256 DKC_SHO_DIGESTSTR_F_TYPE digeststr = (DKC_SHO_DIGESTSTR_F_TYPE)p->DigestStr;
00257 check_();
00258 return digeststr(p->mObj,buff,size);
00259 }
00260
00261
00262 int WINAPI dkcSHODigest(DKC_SECURE_HASH_OBJECT *p,BYTE *buff,size_t size)
00263 {
00264 DKC_SHO_DIGEST_F_TYPE digest = (DKC_SHO_DIGEST_F_TYPE)p->Digest;
00265 check_();
00266 return digest(p->mObj,buff,size);
00267 }
00268
00269
00270
00271
00272 static DKC_INLINE int shc(
00273 UINT hash_option,void *digest_dest,size_t destsize,
00274 const BYTE *data,size_t data_size,dkctBOOL isBinary
00275 )
00276 {
00277 int r = edk_FAILED;
00278 DKC_SECURE_HASH_OBJECT *p = dkcAllocSHO(hash_option);
00279 if(NULL==p){
00280 goto Error;
00281 }
00282
00283 dkcSHOLoad(p,data,data_size);
00284
00285 dkcSHOFinal(p);
00286
00287 if(isBinary){
00288 r = dkcSHODigest(p,digest_dest,destsize);
00289 }else{
00290 r = dkcSHODigestStr(p,digest_dest,destsize);
00291 }
00292 if(DKUTIL_FAILED(r)){
00293 goto Error;
00294 }
00295 r = edk_SUCCEEDED;
00296
00297 Error:
00298 dkcFreeSHO(&p);
00299 return r;
00300 }
00301
00302 int WINAPI dkcSecureHashCalculateBinaryDigest(
00303 UINT hash_option,BYTE *digest_dest,size_t destsize,
00304 const BYTE *data,size_t data_size
00305 ){
00306
00307 return shc(hash_option,digest_dest,destsize,data,data_size,TRUE);
00308 }
00309
00311 int WINAPI dkcSecureHashCalculateStringDigest(
00312 UINT hash_option,char *digest_dest,size_t destsize,
00313 const BYTE *data,size_t data_size
00314 ){
00315
00316 return shc(hash_option,digest_dest,destsize,data,data_size,FALSE);
00317 }
00318
00319
00320
00321
00322 uint8 dkcHash8(uint8 *pd,size_t cycle){
00323 uint32 v = 0;
00324 size_t i;
00325 for(i=0;i<cycle;i++){
00326 v ^= (pd[i] << 3) + v;
00327 }
00328 return (uint8)((v % dkcdUNSIGNED_8BIT_PRIME_NUM) & 0xFF);
00329 }
00330
00331 uint16 dkcHash16(uint8 *pd,size_t cycle){
00332 uint32 v = 0;
00333 size_t i;
00334 for(i=0;i<cycle;i++){
00335 v = (pd[i] << 3) + v;
00336 }
00337 return (uint16)((v % dkcdUNSIGNED_16BIT_PRIME_NUM) & 0xFFFF);
00338 }
00339
00340 uint32 dkcHash24(uint8 *pd,size_t cycle){
00341 uint32 v = 0;
00342 size_t i;
00343 for(i=0;i<cycle;i++){
00344 v ^= (pd[i] << 3) + v;
00345 }
00346 return (v % dkcdUNSIGNED_16BIT_PRIME_NUM) & 0xFFFFFF;
00347 }